aribas - Online na nuvem

PROGRAMA:

NOME

aribas - Intérprete Aritmético Multiprecisão

SINOPSE

aribás [opções] [ari-arquivo> [argumento1>argumento2> ...]]

Esta página do manual foi escrita para o Debian uma vez que o software original não continha um man
Disputas de Comerciais.

DESCRIÇÃO

Aribas é um interpretador interativo adequado para aritmética de grandes inteiros e
aritmética de ponto flutuante multiprecisão. Tem uma sintaxe semelhante a Pascal ou Modula-2,
mas também contém recursos de outras linguagens de programação como C, Lisp, Oberon.

USO

A maneira mais simples de usar aribás é como uma calculadora para aritmética (número inteiro grande). Depois de
aribás é iniciado, ele exibe um prompt ==> e está pronto para aceitar entradas. Basta entrar no
expressão que você deseja calcular, seguido por um ponto final e, em seguida, pressione RETURN, para
exemplo

==> 123 + 456 * 789.

Aribas respostas

-: 359907

O símbolo -: apresenta o resultado.
IMPORTANTE. Para marcar o fim de sua entrada, você deve sempre digitar um ponto final '.' e então
pressione RETURN.

Você pode atribuir o resultado de um cálculo a uma variável, como em

==> F6: = 2 ** 64 + 1.
-: 18446_74407_37095_51617

Isso calcula o 6º número de Fermat (** denota exponenciação) e atribui-o ao
variável F6 (Observe que aribás diferencia maiúsculas de minúsculas, então não é o mesmo que f6) Mais tarde
você pode usar esta variável por exemplo na expressão

==> 123 ** (F6 - 1) mod F6.
-: 688_66214_58712_63971

que mostra (pelo teorema de Fermat) que F6 não é um número primo.
Os três resultados mais recentes são armazenados nas pseudo variáveis _, __ e ___. Para
exemplo, você pode armazenar o último resultado na variável x pelo comando

==> x: = _.
-: 688_66214_58712_63971

Como você pode ver nos exemplos acima, aribás usa o sublinhado _ para estruturar a saída
de grandes inteiros (> = 2 ** 32). Também para a entrada de inteiros, você pode usar o sublinhado, o
a única condição é que imediatamente antes e depois do sublinhado haja dígitos,
exemplo:

==> z: = 123_4567_890.
-: 1234567890

Aqui, a saída não contém sublinhado, o que mostra que z é menor que 2 ** 32.

Aribas tem várias funções integradas para fatoração, por exemplo rho_factorize, o qual
usa o algoritmo rho de Pollard.

==> rho_factorize (F6).

trabalhando ..
fator encontrado após 512 iterações

-: 274177

Para encontrar o cofator restante, dê o comando

==> x: = F6 div _.
-: 6728_04213_10721

Para testar se este fator é primo, o teste probabilístico de Rabin rab_primetest pode ser
aplicado:

==> rab_primetest (x).
-: verdadeiro

A função rho_factorize é bom para encontrar pequenos fatores (digamos até 10 casas decimais
dígitos); para tarefas de fatoração mais complicadas, um algoritmo mais poderoso como o
peneira quadrática qs_factorize deve ser usado

==> qs_factorize (2 ** 128 + 1).

(Dependendo da potência do seu computador, pode levar de alguns segundos a alguns minutos
para obter um fator primo do 7º número de Fermat.)

Control estruturas
A para loop e o enquanto enlaçar aribás tem uma sintaxe como em Modula-2. Por exemplo, o
a sequência de comando a seguir calcula o fatorial de 100.

==> x: = 1;
para i: = 2 para 100 do
x: = x * i;
end;
x.

Como você pode ver neste exemplo, a entrada pode se estender por várias linhas.

O referido para loop é equivalente ao seguinte enquanto laço

==> x: = 1; i: = 2;
enquanto eu <= 100 faço
x: = x * i;
inc (i);
end;
x.

A construção ramificada
if ... então ... Elsif ... outro ... final
também tem a mesma sintaxe do Modula-2.

Multiprecisão flutuante ponto aritmética
Aribas suporta diferentes tipos de números de ponto flutuante que são representados internamente
com mantissas de diferentes comprimentos de bits:

single_float 32 bits
double_float 64 bits
long_float 128 bits

e várias precisões mais altas até um limite dependente da implementação, normalmente 1024 ou
5120 bits, que podem ser determinados pela função max_floatprec (). Por padrão, quando
calculando com números de tipo de dados reais, single_floats são usados. Isso corresponde a um
precisão de 9 a 10 casas decimais. Uma precisão de 5120 bits corresponde a mais de 1500
casas decimais.

A precisão pode ser alterada usando a função set_floatprec. A função leva um
argumento inteiro, que é a precisão desejada em bits. É automaticamente arredondado para
o próximo valor disponível mais alto. Por exemplo, depois

==> set_floatprec(100).
-: 128

a precisão do ponto flutuante é de 128 bits e você pode calcular

==> arctan (sqrt(3)).
-: 1.04719_75511_96597_74615_42144_61093_16762_8

==> _ / pi.
-: 0.33333_33333_33333_33333_33333_33333_33333_33

Utilizador definido funções
O usuário pode definir suas próprias funções. Um exemplo típico parece

==> função fac (n: inteiro): inteiro;
var
x, i: inteiro;
começar
x: = 1;
para i: = 2 para n do
x: = x * i;
end;
retorna x;
final.

Se você digitou corretamente, aribás ecoa o nome da função

-: fato

e de agora em diante você pode usar fac da mesma forma que uma função integrada, por exemplo

==> fac(32).
-: 2_63130_83693_36935_30167_21801_21600_00000

Observe que dentro das definições de função todas as variáveis ​​usadas devem ser declaradas explicitamente,
enquanto no nível superior do aribás variáveis ​​de interpretador podem ser simplesmente criadas por
atribuições. Aqui está outro exemplo, que mostra alguns outros tipos de dados suportados por
aribás:

==> função sqrt_list (n: inteiro): array de real;
var
vec: array [n] de real;
i: inteiro;
começar
para i: = 1 para n do
vec [i-1]: = sqrt (i);
end;
retorno vec;
final.

Esta função retorna uma matriz das raízes quadradas dos inteiros de 1 a n, para
exemplo

==> lista_sqrt(10).
-: (1.00000000, 1.41421356, 1.73205081, 2.00000000,
2.23606798, 2.44948974, 2.64575131, 2.82842712, 3.00000000,
3.16227766)

Em um projeto de programação maior, onde você precisa de várias funções, você não deve inseri-las
diretamente no aribás solicitar, mas preparar as definições de função com um texto externo
editor e salvá-los em um arquivo com a extensão .ari , Por exemplo abcd.ari . Este ficheiro
pode então ser carregado por aribás usando o comando

==> carregar ("abcd").

Se houver um erro de sintaxe no arquivo, você receberá uma mensagem de erro no formulário

erro na linha <= 23 do arquivo carregado
se: fim esperado

que diz a você (neste exemplo) que há um erro no if construir na linha 23 ou
anteriormente no arquivo. (Observe que as mensagens de erro às vezes não são muito precisas.)
pode então corrigir o erro e carregar o arquivo novamente.

Online ajudar
O comando

==> símbolos (aribas).

retorna uma lista de todas as palavras-chave e nomes de funções integradas de aribás. Esta lista tem
cerca de 200 entradas, e começa e termina da seguinte maneira:

(ARGV, _, __, ___, abs, alloc, e, arccos, arcsin, arctan, arctan2, aribas, array, atof,
atoi, begin, binary, bit_and, bit_clear, bit_length, ......, tolower, toupper,
transcrição, verdadeiro, trunc, tipo, usuário, var, versão, enquanto, gravação, write_block, write_byte,
escreval)

Para a maioria dos símbolos nesta lista, você pode obter uma breve ajuda online usando a função
ajuda(). Por exemplo, o comando

==> ajuda (ARGV).

dá uma informação sobre a variável embutida ARGV, enquanto que

==> ajuda (enquanto).

descreve a sintaxe do enquanto ciclo. Se você precisar de mais informações do que as contidas
na ajuda online, consulte a documentação que pode ser encontrada em / usr / share / doc / aribas.

Como funciona o dobrador de carta de canal para saída
Para terminar um aribás sessão, tipo saída no aribás pronto

==> sair

e então pressione a tecla RETURN (ENTER).

Se você não quer sair aribás, mas quero sair de um loop infinito ou um
cálculo que dura muito tempo, digite CONTROL-C (se você estiver executando aribás de dentro
Emacs, você deve pressionar CONTROL-C duas vezes). Isso irá (na maioria dos casos) interromper o atual
cálculo e retorno ao aribás pronto.

Quando você não está usando a interface Emacs, mas a versão de linha de comando do aribás, tu
às vezes, chegam à seguinte situação: alguma linha anterior contém um erro de digitação,
mas você não pode retornar a essa linha para corrigi-lo. Neste caso, você deve simplesmente digitar um
ponto final '.', seguido por RETURN. Você receberá uma mensagem de erro que pode ser seguramente
ignorar e um novo prompt ==> aparece, permitindo que você tente novamente.

COMANDO LINHA ARGUMENTOS

aribás [opções] [ari-arquivo> [argumento1>argumento2> ...]]

opções
As seguintes opções estão disponíveis:

-q (modo silencioso) Suprime todas as mensagens na tela (versão nº, aviso de copyright,
etc.) quando aribás começou

-v (modo detalhado, padrão) Não suprime mensagens na tela quando aribás is
iniciado.

-c
aribás faz sua própria quebra de linha ao gravar na tela. Normalmente supõe
que a tela (ou a janela na qual aribás corridas) tem 80 colunas. Com o -c
opção você pode definir outro número, que deve estar entre 40 e 160 (em decimal
representação). Por exemplo, se você executar aribás em uma janela Xterm com 72
colunas, use a opção -c72 (ou -c 72, o espaço entre -c e o número é
opcional).

-m
Aqui é um número (em representação decimal) entre 500 e 32000. Este
número indica quantos kilobytes de RAM aribás deve usar para o aribás pilha.
O valor padrão depende das opções usadas quando aribás foi compilado. Tipicamente,
no UNIX ou LINUX é de 6 Megabytes, correspondendo a -m6000

-h of ajudar arquivo>
A ajuda online de aribás depende de um arquivo aribas.hlp que deve estar situado em
o intervalo da variável de ambiente PATH. Se este não for o caso, você pode especificar
o caminho exato do arquivo de ajuda com a opção -h. Se por exemplo o arquivo
aribas.hlp está no diretório / usr / local / lib, use a opção -h / usr / local / lib
(o espaço após -h não é necessário). A opção -h também pode ser usada se a ajuda
o arquivo tem um nome diferente. Se o arquivo de ajuda for denominado help-aribas e estiver no
diretório / home / joe / ari, use -h / home / joe / ari / help-aribas.

Com um pacote Debian devidamente instalado de aribás não deveria ser necessário
use esta opção.

-p
Com esta opção, você pode especificar um caminho de pesquisa para carregar arquivos com aribás fonte
código. pode ser o nome do caminho (absoluto) de um diretório ou
vários nomes de caminhos separados por dois pontos. Suponha que você tenha chamado aribás com
a opção

-p / usr / local / lib / aribas:~ / ari / examples

e que seu diretório pessoal é / home / alice /. Então o comando

==> carga ("fator").

irá pesquisar o arquivo factor.ari primeiro no diretório atual, depois no
diretório / usr / local / lib / aribas e finalmente em / home / alice / ari / examples.

-b Modo em lote ao carregar um aribás arquivo de código-fonte da linha de comando, consulte
abaixo.

As opções de uma letra que não requerem argumentos podem ser combinadas, por exemplo

aribas -q -b

é equivalente a

aribas-qb

Mais comando linha argumentos

O próximo argumento da linha de comando após as opções é interpretado como o nome de um
arquivo com aribás Código fonte. Se o nome do arquivo tiver a extensão .ari, isso
extensão pode ser omitida. O arquivo é carregado como se o comando carga(" ")
foi dado após o início de aribás no aribás mensagem. Se o arquivo não for
encontrado no diretório atual, é pesquisado nos diretórios especificados pelo
opção -p. Se a opção -b foi fornecida, o arquivo é carregado e executado.
Depois aribás sai sem mostrar o prompt. Se o arquivo não pode ser carregado
completamente por causa de um erro, aribás sai imediatamente após a mensagem de erro.

...
Quando outros argumentos de linha de comando seguem , eles são coletados (como
cordas) junto com no vetor ARGV que pode ser acessado de
dentro aribás. Exemplo: se você ligar aribás com a linha de comando

startup aribas 4536 eisenstein

e o diretório atual contém o arquivo startup.ari, então aribás carrega e
o vetor ARGV tem a forma

==> ARGV.
-: ("inicialização", "4536", "eisenstein")

Se você precisa de alguns argumentos como números e não como strings, você pode transformá-los
Sua (ou em cima de); em nosso exemplo

==> x: = atoi (ARGV [1]).
-: 4536

vai fazer isso. O comprimento do vetor ARGV pode ser determinado por comprimento (ARGV).

CORRENDO ARIBAS DENTRO EMACS

Você pode correr aribás de dentro do Emacs, dando o comando (no minibuffer do Emacs)

Mx run-aribas

(Se você não tiver uma tecla META, use ESC x em vez de Mx) Então aribás será carregado em
uma janela Emacs com o nome * aribas * e você pode editar sua entrada para aribás com o de costume
Comandos Emacs.

Se sua entrada terminar com um ponto final '.' e você pressiona RETURN, ele é enviado para aribás. Se
no entanto, sua entrada completa não termina com um ponto final, (por exemplo, em resposta a um
readln), a entrada é enviada para aribás por Cj (Control-j) ou Cc RETURN.

Se você quiser repetir uma entrada anterior, Mp (ou ESC p) retrocede através da entrada
histórico e Mn (ou ESC n) avança.

Um Control-C é enviado para aribás por Cc Cc (pressione Cc duas vezes).

Também é possível começar aribás do Emacs com argumentos de linha de comando. Por esta
propósito o comando

Cu Mx run-aribas

tem que ser dado. Em seguida, um prompt

run-aribas: aribas

aparece no Minibuffer do Emacs e você pode completar a linha de comando, por exemplo

run-aribas: inicialização do aribas 4536 eisenstein

(Veja acima).

CONFIGURAÇÃO ARQUIVO

Opções para correr aribás pode ser especificado também usando um arquivo de configuração com o nome
.arc. Aribas procura um arquivo de configuração na seguinte ordem:

1) o diretório atual
2) o diretório inicial do usuário

Existe uma terceira possibilidade: você pode definir uma variável de ambiente ARIRC contendo o
nome do arquivo de configuração (que pode ser diferente de .arirc), incluindo o completo
caminho.

No arquivo de configuração, você pode especificar todas as opções de linha de comando descritas acima, que
comece com um sinal -, no entanto, uma linha separada deve ser usada para cada opção. Linhas
começando com o caractere # ou as linhas vazias são ignoradas. Além das opções
descrito acima, o arquivo de configuração pode conter aribás Código fonte. Para este propósito
deve haver uma leitura de linha

-iniciar

Então, tudo após esta linha é tratado como aribás código-fonte e executado quando aribás
começou.

A existência de um arquivo de configuração para aribás não exclui a possibilidade de dar
argumentos de linha de comando. Se uma opção (por exemplo, a opção -m) for especificada tanto no
arquivo de configuração e a linha de comando, mas com valores diferentes, a especificação
na linha de comando é válido. Analogamente, uma opção -v na linha de comando substitui um -q
opção no arquivo de configuração. Se houver código -init no arquivo de configuração e um
argumento na linha de comando, então o código -init é executado primeiro e
depois o é carregado e seu código executado.

Use aribas online usando serviços onworks.net