Speakeasy (ambiente computacional) - Speakeasy (computational environment)
 | |
| Desenvolvedor (s) | Speakeasy Computing Corporation |
|---|---|
| Versão estável | IV Iota / 2006 |
| Escrito em | Mortran , FORTRAN , C |
| Sistema operacional | Windows , macOS , RedHat Linux , SUSE Linux , Mandrake Linux , Debian , Solaris , HP-UX |
| Modelo | Computação técnica |
| Licença | Trialware |
| Paradigma | imperativo |
|---|---|
| Projetado por | Stanley Cohen |
| Desenvolvedor | Speakeasy Computing Corporation |
| Apareceu pela primeira vez | 1964 |
| Disciplina de digitação | dinâmico |
| Influenciado por | |
| APL | |
| Influenciado | |
| MATLAB | |
Speakeasy era um ambiente interativo de computação numérica que também apresentava uma linguagem de programação interpretada . Ele foi inicialmente desenvolvido para uso interno na Divisão de Física do Laboratório Nacional de Argonne pelo físico teórico Stanley Cohen . Ele acabou fundando a Speakeasy Computing Corporation para disponibilizar o programa comercialmente.
Speakeasy é um pacote numérico de longa duração. Na verdade, a versão original do ambiente foi construída em torno de um repositório central de dados dinâmicos chamado "Armazenamento nomeado", desenvolvido no início dos anos 1960, enquanto a versão mais recente foi lançada em 2006.
O objetivo do Speakeasy era tornar o trabalho computacional dos físicos do Laboratório Nacional de Argonne mais fácil.
História
O Speakeasy foi inicialmente concebido para funcionar em mainframes (o único tipo de computador na época) e, posteriormente, foi portado para novas plataformas ( minicomputadores , computadores pessoais ) à medida que se tornavam disponíveis. A portabilidade do mesmo código em plataformas diferentes foi facilitada usando macros de metalinguagem Mortran para enfrentar dependências de sistemas e deficiências e diferenças de compiladores. O Speakeasy está atualmente disponível em várias plataformas: PCs executando Windows , macOS , Linux , computadores departamentais e estações de trabalho executando vários tipos de Linux, AIX ou Solaris .
Speakeasy também foi um dos primeiros ambientes de computação numérica interativa, tendo sido implementado de tal forma em um sistema CDC 3600 , e mais tarde em máquinas IBM TSO como um estava em beta-teste no Argonne National Laboratory na época. Em 1984 estava disponível no Digital Equipment Corporation 's VAX sistemas.
Quase desde o início (já que a funcionalidade de vinculação dinâmica foi disponibilizada nos sistemas operacionais), o Speakeasy apresenta a capacidade de expandir seu vocabulário operacional usando módulos separados, dinamicamente vinculados ao processador central conforme necessário. Por esse motivo, tais módulos foram chamados de "linkules" (LINKable-modULES). Eles são funções com uma interface generalizada, que pode ser escrito em Fortran ou em C . A independência de cada um dos novos módulos dos demais e do processador principal é de grande ajuda na melhoria do sistema, principalmente no passado.
Essa maneira fácil de expandir as funcionalidades do processador principal foi frequentemente explorada pelos usuários para desenvolver seus próprios pacotes especializados. Além dos programas, funções e sub-rotinas que o usuário pode escrever na linguagem interpretada do próprio Speakeasy, os linkules agregam funcionalidades realizadas com as performances típicas de programas compilados.
Entre os pacotes desenvolvidos pelos usuários, um dos mais importantes é o "Modeleasy", originalmente desenvolvido como "FEDeasy" no início dos anos 1970 no departamento de pesquisa do Federal Reserve Board of Governors em Washington DC. Modeleasy implementa objetos e funções especiais para estimativa e simulação de grandes modelos econométricos. Sua evolução levou eventualmente à sua distribuição como um produto independente.
Sintaxe
O símbolo : _ (dois pontos + sublinhado) é o logotipo do Speakeasy e o prompt da sessão interativa.
O cifrão é usado para delimitar comentários; o E comercial é usado para continuar uma instrução na seguinte linha física, caso em que o prompt se torna : & (dois pontos + E comercial); um ponto-e-vírgula pode separar instruções escritas na mesma linha física.
$ suppose you have a very long statement, $ you can write it on multiple physical lines using "&" $ at the end of the line to be continued: :_ the_return_value = this_is_a_function_with_many_arguments(argument_1, argument_2, & :& argument_3, argument_4, argument_5, argument_6) $ on the other hand, you can collect several short statements $ on a single physical line using ";" :_ a=1; b=2; c=3; d=4
Como o próprio nome indica, o Speakeasy teve como objetivo expor uma sintaxe o mais amigável possível para o usuário e o mais próximo possível da linguagem falada. O melhor exemplo disso é dado pelo conjunto de comandos para leitura / gravação de dados de / para o armazenamento permanente. Por exemplo, (as palavras-chave dos idiomas estão em maiúsculas para esclarecer o ponto):
:_ GET my_data FROM LIBRARY my_project :_ KEEP my_data AS a_new_name_for_mydata IN LIBRARY other_project
Variáveis (ou seja, objetos Speakeasy) recebem um nome de até 255 caracteres, quando a opção LONGNAME está ativada, até 8 caracteres caso contrário (para compatibilidade com versões anteriores). Eles são digitados dinamicamente, dependendo do valor atribuído a eles.
:_ a=1 :_ whatis a A is a REAL SCALAR. :_ a="now a character array" :_ whatis a A is a 21 element CHARACTER ARRAY.
Os argumentos de funções geralmente não precisam ser colocados entre parênteses ou separados por vírgulas, desde que o contexto permaneça claro e inequívoco. Por exemplo:
:_ sin(grid(-pi,pi,pi/32)) $ fully specified syntax
pode ser escrito:
:_ sin grid(-pi,pi,pi/32) $ the argument of function sin is not surrounded by parenthesis
ou mesmo
:_ sin grid(-pi pi pi/32) $ the arguments of function grid can be separated by spaces
Muitas outras simplificações de sintaxe são possíveis; por exemplo, para definir um objeto denominado 'a' com valor de uma matriz de dez elementos de zeros, pode-se escrever qualquer uma das seguintes instruções:
:_ a=array(10:0,0,0,0,0,0,0,0,0,0) :_ a=0,0,0,0,0,0,0,0,0,0 :_ a=0 0 0 0 0 0 0 0 0 0 :_ a=ints(10)*0 :_ a=10:
Speakeasy é uma linguagem orientada a vetores : dando um argumento estruturado a uma função de um escalar, o resultado é geralmente um objeto com a mesma estrutura do argumento, em que cada elemento é o resultado da função aplicada ao elemento correspondente do argumento. No exemplo dado acima, o resultado da função sin aplicada à matriz (vamos chamá-la de x ) gerada pela grade de funções é a resposta da matriz cujo elemento resposta (i) é igual a sin ( x (i)) para cada i de 1 a noels (x) (o número de elementos de x ). Em outras palavras, a declaração
:_ a=sin(grid(-pi pi pi/32))
é equivalente ao seguinte fragmento de programa:
x=grid(-pi pi pi/32) $ generates an array of real numbers from -pi to pi, stepping by pi/32 for i = 1,noels(x) $ loops on the elements of x a(i) = sin(x(i)) $ evaluates the i-th element of a next i $ increment the loop index
As instruções orientadas a vetores evitam escrever programas para esses loops e são muito mais rápidas do que eles.
Área de trabalho e objetos
Já na primeira instrução da sessão, o usuário pode definir o tamanho do "armazenamento nomeado" (ou "área de trabalho", ou "alocador"), que é alocado de uma vez por todas no início da sessão. Dentro dessa área de trabalho de tamanho fixo, o processador Speakeasy cria e destrói dinamicamente os objetos de trabalho conforme necessário. Um mecanismo de coleta de lixo ajustável pelo usuário é fornecido para maximizar o tamanho do bloco livre na área de trabalho, empacotando os objetos definidos na extremidade inferior ou na extremidade superior do alocador. A qualquer momento, o usuário pode perguntar sobre o espaço usado ou restante na área de trabalho.
:_ SIZE 100M $ very first statement: the work area will be 100MB :_ SIZE $ returns the size of the work area in the current session :_ SPACELEFT $ returns the amount of data storage space currently unused :_ SPACENOW $ returns the amount of data storage space currently used :_ SPACEPEAK $ returns the maximum amount of data storage space used in the current session
Orientação de objeto bruto
Dentro de restrições razoáveis de conformidade e compatibilidade, os objetos Speakeasy podem ser operados usando a mesma sintaxe algébrica.
Deste ponto de vista, e considerando a natureza dinâmica e estruturada dos dados mantidos no "armazenamento nomeado", é possível dizer que o Speakeasy desde o início implementou uma forma bastante crua de sobrecarga de operador e uma abordagem pragmática de alguns recursos do que mais tarde foi chamado de " Programação Orientada a Objetos ", embora não tenha evoluído mais nessa direção.
$ The following example shows how a Matrix-family object and an Array-family object $ with the same structure and values are operated on differently although using the $ same "*" and "/" operator: in the first case using the matrix algebra and in the $ second case operating on an element-by-element basis. |
|
:_ a=matrix(2,2:1,2,3,4) ; a A (A 2 by 2 Matrix) 1 2 3 4 :_ a*a A*A (A 2 by 2 Matrix) 7 10 15 22 :_ a/a A/A (A 2 by 2 Matrix) 1 0 0 1 |
:_ aa=array(2,2:1,2,3,4) ; aa AA (A 2 by 2 Array) 1 2 3 4 :_ aa*aa AA*AA (A 2 by 2 Array) 1 4 9 16 :_ aa/aa AA/AA (A 2 by 2 Array) 1 1 1 1 |
As famílias de objetos
O Speakeasy fornece um monte de "famílias" predefinidas de objetos de dados: escalares, matrizes (até 15 dimensões), matrizes, conjuntos, séries temporais.
Os dados elementares podem ser do tipo real (8 bytes), complexo (2x8 bytes), literal de caractere ou literal de nome (os elementos das matrizes podem ser reais ou complexos, os valores da série temporal só podem ser reais).
Valores ausentes
Para processamento de série temporal , cinco tipos de valores ausentes são fornecidos. Eles são denotados por NA (não disponível), NC (não computável), ND (não definido), junto com NB e NE cujo significado não é predeterminado e é deixado disponível para o desenvolvedor de linkules. Eles são representados internamente por valores numéricos específicos (e muito pequenos), agindo como códigos.
Todas as operações de série temporal cuidam da presença de valores perdidos, propagando-os de forma adequada nos resultados.
Dependendo de uma configuração específica, os valores ausentes podem ser representados pela notação acima, por um símbolo de ponto de interrogação ou um espaço em branco (útil em tabelas). Quando usado na entrada, o ponto de interrogação é interpretado como um valor ausente NA.
:_ b=timeseries(1,2,3,4 : 2010 1 4) :_ b B (A Time Series with 4 Components) 1 2 3 4 :_ b(2010 3) = ? :_ showmval qmark :_ b B (A Time Series with 4 Components) 1 2 ? 4 :_ 1/b 1/B (A Time Series with 4 Components) 1 .5 ? .25 :_ showmval explain :_ b B (A Time Series with 4 Components) 1 2 N.A. 4 :_ 1/b 1/B (A Time Series with 4 Components) 1 .5 N.C. .25
Em objetos numéricos que não sejam séries temporais, o conceito de "valores ausentes" não tem sentido e as operações numéricas sobre eles usam os valores numéricos reais, independentemente de corresponderem a "códigos de valores ausentes" ou não (embora "códigos de valores ausentes" possam ser inseridos e mostrado como tal).
:_ 1+? 1+? = 1.00 :_ 1/? 1/? = 5.3033E36 :_ 1*? 1*? = ?
Observe que, em outros contextos, um ponto de interrogação pode ter um significado diferente: por exemplo, quando usado como o primeiro (e possivelmente o único) caractere de uma linha de comando, significa que a solicitação para mostrar mais partes de uma longa mensagem de erro (que termina com um símbolo "+").
:_ a=array(10000,10000:) ARRAY(10000,10000:) In line "A=ARRAY(10000,10000:)" Too much data.+ :_ ? Allocator size must be at least 859387 kilobytes.+ :_ ? Use FREE to remove no longer needed data or use CHECKPOINT to save allocator for later restart.+ :_ ? Use NAMES to see presently defined names. Use SIZE & RESTORE to restart with a larger allocator. :_ ? NO MORE INFORMATION AVAILABLE.
Valores lógicos
Algum suporte é fornecido para valores lógicos, operadores relacionais (a sintaxe Fortran pode ser usada) e expressões lógicas.
Os valores lógicos são armazenados na verdade como valores numéricos: com 0 significando falso e diferente de zero (1 na saída) significando verdadeiro.
:_ a = 1 2 3 4 5 :_ b = 1 3 2 5 4 :_ a>b A>B (A 5 Component Array) 0 0 1 0 1 :_ a<=b A<=B (A 5 Component Array) 1 1 0 1 0 :_ a.eq.b A.EQ.B (A 5 Component Array) 1 0 0 0 0 :_ logical(2) $ this changes the way logical values are shown :_ a>b; a<=b; a.eq.b A>B (A 5 Component Array) F F T F T A<=B (A 5 Component Array) T T F T F A.EQ.B (A 5 Component Array) T F F F F
Programação
Objetos especiais, como objetos "PROGRAM", "SUBROUTINE" e "FUNCTION" (chamados coletivamente de procedimentos ), podem ser definidos para automação de operações. Outra forma de executar várias instruções com um único comando é armazená-las em um arquivo de uso e fazer com que o processador as leia por meio do comando USE.
Use-arquivos
"USAR" um arquivo de uso é a maneira mais simples de executar várias instruções com o mínimo de entrada digitada. (Esta operação corresponde aproximadamente a "origem" de um arquivo em outras linguagens de script.)
Um arquivo de uso é uma fonte de entrada alternativa para o console padrão e pode conter todos os comandos que um usuário pode inserir pelo teclado (portanto, nenhuma construção de controle de fluxo multilinha é permitida). O processador lê e executa os arquivos de uso uma linha por vez.
A execução do arquivo de uso pode ser concatenada, mas não aninhada, ou seja, o controle não retorna ao chamador na conclusão do arquivo de uso chamado.
Procedimentos
A capacidade total de programação é alcançada usando "procedimentos". Na verdade, são objetos Speakeasy, que devem ser definidos na área de trabalho para serem executados. Uma opção está disponível para fazer com que os procedimentos sejam automaticamente recuperados e carregados do armazenamento externo conforme forem necessários.
Os procedimentos podem conter qualquer uma das construções de controle de fluxo de execução disponíveis na linguagem de programação Speakeasy.
Programas
Um programa pode ser executado simplesmente invocando seu nome ou usando-o como argumento do comando EXECUTE. No último caso, um outro argumento pode identificar um rótulo a partir do qual a execução começará. Os programas Speakeasy diferem dos outros procedimentos por serem executados no mesmo "nível" de escopo ao qual são referenciados, portanto, eles têm visibilidade total de todos os objetos definidos naquele nível, e todos os objetos criados durante sua execução serão deixados lá para subseqüentes usa. Por esse motivo, nenhuma lista de argumentos é necessária.
Sub-rotinas e funções
As sub-rotinas e funções são executadas em um novo nível de escopo, que é removido quando são concluídas. A comunicação com o nível de escopo da chamada é realizada através da lista de argumentos (em ambas as direções). Isso implementa o ocultamento de dados, ou seja, os objetos criados em uma sub-rotina ou função não são visíveis para outra sub-rotina e funções, mas por meio de listas de argumentos.
Um nível global está disponível para armazenar objetos que devem ser visíveis de dentro de qualquer procedimento, por exemplo, os próprios procedimentos.
As funções diferem das sub-rotinas porque também retornam um valor funcional; a referência a eles pode ser parte de uma instrução mais complexa e é substituída pelo valor funcional retornado ao avaliar a instrução.
Em certa medida, as sub-rotinas e funções do Speakeasy são muito semelhantes aos procedimentos Fortran de mesmo nome.
Controle de fluxo
Uma construção IF-THEN-ELSE está disponível para execução condicional e duas formas de construção FOR-NEXT são fornecidas para loop.
IF (logical-expression) THEN true-block [ELSE false-block] END IF |
FOR index = min, max [, step] loop-block NEXT index |
FOR value IN set-of-values loop-block NEXT value |
Uma instrução "GO TO label " é fornecida para pular, enquanto uma instrução GO TO computada do tipo Fortran pode ser usada para múltiplas ramificações.
... IF (logical-expression) GO TO label ... label: ... |
$ In the following statement $ selector must be >= 1 and <= N GO TO label1, label2, ..., labelN : selector ... label1: ... label2: ... ... labelN: ... |
Um mecanismo ON ERROR, com várias opções, fornece um meio para tratamento de erros.
Escrita de Linkule
Linkules são funções geralmente escritas em Fortran (ou, sem suporte, em C). Com a ajuda de macros Mortran ou C e uma biblioteca de API, eles podem interagir com a área de trabalho do Speakeasy para recuperar, definir e manipular qualquer objeto do Speakeasy.
A maior parte do vocabulário operacional do Speakeasy é implementada por meio de links. Eles podem ser vinculados estaticamente ao mecanismo principal ou carregados dinamicamente conforme necessário, desde que sejam compilados corretamente como objetos compartilhados (unix) ou dll (windows).