aribas - Online nel cloud

PROGRAMMA:

NOME

aribas - Interprete di aritmetica multiprecisione

SINOSSI

arib [Opzioni] [file ari> [arg1>arg2> ...]]

Questa pagina man è stata scritta per Debian poiché il software originale non conteneva un man
.

DESCRIZIONE

Ariba è un interprete interattivo adatto per l'aritmetica dei grandi interi e
aritmetica in virgola mobile multiprecisione. Ha una sintassi simile a Pascal o Modula-2,
ma contiene anche funzionalità di altri linguaggi di programmazione come C, Lisp, Oberon.

USO

Il modo più semplice per usare arib è come una calcolatrice per l'aritmetica (grande numero intero). Dopo
arib è avviato, viene visualizzato un prompt ==> ed è pronto ad accettare input. Basta inserire il
espressione che si desidera calcolare, seguita da un punto, quindi premere INVIO, per
esempio

==> 123 + 456*789.

Ariba risposte

-: 359907

Il simbolo -: introduce il risultato.
IMPORTANTE. Per contrassegnare la fine del tuo input, devi sempre digitare un punto '.' poi
premere INVIO.

È possibile assegnare il risultato di un calcolo a una variabile, come in

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

Questo calcola il 6° numero di Fermat (** denota l'elevamento a potenza) e lo assegna al
variabile F6 (nota che arib fa distinzione tra maiuscole e minuscole, quindi non è lo stesso di f6). Dopo
puoi usare questa variabile per esempio nell'espressione

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

che mostra (per il teorema di Fermat) che F6 non è un numero primo.
I tre risultati più recenti sono memorizzati nelle pseudo variabili _, __e ___. For
esempio puoi memorizzare l'ultimo risultato nella variabile x con il comando

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

Come puoi vedere negli esempi precedenti, arib usa il carattere di sottolineatura _ per strutturare l'output
di numeri interi grandi (>= 2**32). Anche per l'immissione di numeri interi è possibile utilizzare il carattere di sottolineatura, il
l'unica condizione è che immediatamente prima e dopo il carattere di sottolineatura ci siano delle cifre,
esempio:

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

Qui l'output non contiene trattini bassi, il che mostra che z è inferiore a 2**32.

Ariba ha diverse funzioni integrate per la fattorizzazione, ad esempio rho_fattorizzare, quale
utilizza l'algoritmo rho di Pollard.

==> rho_factorize(F6).

Lavorando ..
fattore trovato dopo 512 iterazioni

-: 274177

Per trovare il cofattore rimanente, dai il comando

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

Per verificare se questo fattore è primo, il test probabilistico di Rabin rab_primetest può essere
applicato:

==> rab_primetest(x).
-: vero

La funzione rho_fattorizzare è utile per trovare piccoli fattori (diciamo fino a 10 decimali
cifre); per compiti di fattorizzazione più complicati un algoritmo più potente come il
setaccio quadratico qs_fattorizzare dovrebbe essere usato

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

(A seconda della potenza del tuo computer, ci vorranno da pochi secondi a qualche minuto
per ottenere un fattore primo del settimo numero di Fermat.)

Control strutture
I per ciclo e il while entrare arib hanno una sintassi come in Modula-2. Ad esempio, il
la seguente sequenza di comandi calcola il fattoriale di 100.

==> x := 1;
per i: = 2 a 100 fare
x := x*io;
fine;
x.

Come puoi vedere in questo esempio, l'input può estendersi su più righe.

Quanto sopra per loop è equivalente al seguente while loop

==> x := 1; io := 2;
mentre io <= 100 do
x := x*io;
inc (i);
fine;
x.

Il costrutto di ramificazione
if ... poi ... else ... altro ... fine
ha anche la stessa sintassi di Modula-2.

Multiprecisione galleggiante punto aritmetica
Ariba supporta diversi tipi di numeri in virgola mobile che sono rappresentati internamente
con mantisse di diversa lunghezza di bit:

single_float 32 bit
double_float 64 bit
long_float 128 bit

e diverse precisioni superiori fino a un limite dipendente dall'implementazione, tipicamente 1024 o
5120 bit, che possono essere determinati dalla funzione max_floatprec(). Per impostazione predefinita, quando
calcolo con numeri di tipo di dati di rose, vengono utilizzati single_floats. Questo corrisponde ad a
precisione da 9 a 10 decimali. Una precisione di 5120 bit corrisponde a oltre 1500
decimali.

La precisione può essere modificata utilizzando la funzione set_floatprec. La funzione prende uno
argomento intero, che è la precisione desiderata in bit. Viene automaticamente arrotondato a
il valore immediatamente superiore disponibile. Ad esempio, dopo

==> set_floatprec(100).
-: 128

la precisione in virgola mobile è 128 bit e puoi calcolare

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

==> _/pi.
-: 0.33333_33333_33333_33333_33333_33333_33333_33

Utente definito funzioni
L'utente può definire le proprie funzioni. Un tipico esempio sembra

==> funzione fac(n: intero): intero;
var
x,i: intero;
iniziare
x: = 1;
per i: = 2 per n fare
x := x*io;
fine;
restituire x;
fine.

Se l'hai inserito correttamente, arib fa eco al nome della funzione

-: fa

e d'ora in poi puoi usare fac allo stesso modo di una funzione integrata, ad es

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

Nota che all'interno delle definizioni di funzione tutte le variabili utilizzate devono essere dichiarate esplicitamente,
considerando che al livello più alto del arib le variabili dell'interprete possono essere semplicemente create da
Compiti. Ecco un altro esempio, che mostra alcuni altri tipi di dati supportati da
arib:

==> funzione sqrt_list(n: intero): array di reali;
var
vec: array[n] di reale;
i: intero;
iniziare
per i: = 1 per n fare
vec[i-1] := sqrt(i);
fine;
ritorno vec;
fine.

Questa funzione restituisce un array delle radici quadrate degli interi da 1 a n, per
esempio

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

In un progetto di programmazione più grande in cui hai bisogno di diverse funzioni non le inseriresti
direttamente presso il arib prompt ma preparare le definizioni delle funzioni con un testo esterno
editor e salvali in un file con estensione .ari , Per esempio abcd.ari . Questa vita
può quindi essere caricato da arib usando il comando

==> load("abcd").

Se c'è un errore di sintassi nel file, ricevi un messaggio di errore del modulo

errore nella riga <= 23 del file caricato
se: fine prevista

che ti dice (in questo esempio) che c'è un errore nel if costruire nella riga 23 o
prima nel file. (Nota che i messaggi di errore a volte non sono molto precisi.) Tu
può quindi correggere l'errore e caricare nuovamente il file.

Online Aiuto
Il comando

==> simboli (aribas).

restituisce un elenco di tutte le parole chiave e i nomi delle funzioni integrate di arib. Questa lista ha
circa 200 voci, e inizia e finisce come segue:

(ARGV, _, __, ___, abs, alloc e, arccos, arcsin, arctan, arctan2, aribas, array, atof,
atoi, inizio, binario, bit_e, bit_clear, bit_length, ...... , tolower, toupper,
trascrizione, true, trunc, type, user, var, version, while, write, write_block, write_byte,
scrivere)

Per la maggior parte dei simboli in questo elenco, è possibile ottenere una breve guida in linea utilizzando la funzione
Aiuto(). Ad esempio, il comando

==> aiuto(ARGV).

fornisce informazioni sulla variabile incorporata ARGV, mentre

==> aiuto (mentre).

descrive la sintassi di while ciclo continuo. Se hai bisogno di più informazioni di quelle contenute
nella guida in linea, consultare la documentazione che si trova in /usr/condividi/doc/aribas.

Come a exit
Per finire un arib sessione, tipo exit alla arib pronto

==> esci

e quindi premere il tasto INVIO (INVIO).

Se non vuoi andartene arib, ma vuoi uscire da un ciclo infinito o a
calcolo che dura troppo a lungo, digita CONTROL-C (se stai correndo arib dall'interno
Emacs, devi premere CONTROL-C due volte). Questo (nella maggior parte dei casi) fermerà la corrente
calcolo e tornare al arib richiesta.

Quando non si utilizza l'interfaccia Emacs ma la versione a riga di comando di arib, Si
a volte ci si trova nella seguente situazione: alcune righe precedenti contengono un errore di digitazione,
ma non puoi tornare a quella riga per correggerla. In questo caso dovresti semplicemente digitare a
punto '.' , seguito da RETURN. Riceverai un messaggio di errore che puoi tranquillamente
ignora e un nuovo prompt ==> appare, permettendoti di riprovare.

COMANDO LINE ARGOMENTI

arib [Opzioni] [file ari> [arg1>arg2> ...]]

Opzioni
Sono disponibili le seguenti opzioni:

-q (modalità silenziosa) Sopprime tutti i messaggi sullo schermo (versione n., avviso di copyright,
ecc.) quando arib è iniziato

-v (modalità dettagliata, impostazione predefinita) Non sopprime i messaggi sullo schermo quando arib is
iniziato.

-c
arib fa la propria interruzione di riga durante la scrittura sullo schermo. Normalmente suppone
che lo schermo (o la finestra in cui arib corre) ha 80 colonne. Con il -c
opzione è possibile impostare un altro numero, che deve essere compreso tra 40 e 160 (in decimale
rappresentazione). Ad esempio, se corri arib in una finestra Xterm con 72
colonne, usa l'opzione -c72 (o -c 72, lo spazio tra -c e il numero è
opzionale).

-m
Qui è un numero (in rappresentazione decimale) compreso tra 500 e 32000. Questo
numero indica quanti Kilobyte di RAM arib dovrebbe usare per il arib mucchio.
Il valore predefinito dipende dalle opzioni utilizzate quando arib è stato compilato. Tipicamente,
sotto UNIX o LINUX è 6 Megabyte, corrispondente a -m6000

-h of Aiuto file>
L'aiuto in linea di arib dipende da un file aribas.hlp che dovrebbe trovarsi in
l'intervallo della variabile d'ambiente PATH. Se questo non è il caso puoi specificare
il percorso esatto del file della guida con l'opzione -h. Se per esempio il file
aribas.hlp è nella directory / Usr / local / lib, usa l'opzione -h / Usr / local / lib
(lo spazio dopo -h non è necessario). L'opzione -h può essere utilizzata anche se l'aiuto
il file ha un nome diverso. Se il file di aiuto si chiama help-aribas e si trova nel
directory /home/joe/ari, usa -h/home/joe/ari/help-aribas.

Con un pacchetto Debian installato correttamente di arib non dovrebbe essere necessario
utilizzare questa opzione.

-p
Con questa opzione puoi specificare un percorso di ricerca per caricare i file con arib source
codice. può essere il percorso (assoluto) di una directory o
diversi percorsi separati da due punti. Supponi di aver chiamato arib con
l'opzione

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

e che la tua directory home sia /home/alice/. Poi il comando

==> carico("fattore").

cercherà il file factor.ari prima nella directory corrente, poi nel
directory /usr/local/lib/aribas e infine in /home/alice/ari/examples.

-b Modalità batch durante il caricamento e arib file del codice sorgente dalla riga di comando, vedi
qua sotto.

Le opzioni di una lettera che non richiedono argomenti possono essere unite, ad esempio

aribas -q -b

è equivalente

aribas -qb

Inoltre command linea argomenti

Il successivo argomento della riga di comando dopo le opzioni viene interpretato come il nome di a
file con arib codice sorgente. Se il nome del file ha estensione .ari, questo
l'estensione può essere omessa. Il file viene caricato come se il comando carico(" ")
era stato dato dopo l'inizio di arib alla arib richiesta. Se il file non lo è
trovato nella directory corrente viene cercato nelle directory specificate dal
-p opzione. Se è stata data l'opzione -b, il file viene caricato ed eseguito.
In seguito arib esce senza mostrare il prompt. Se il file non può essere caricato
completamente a causa di un errore, arib esce subito dopo il messaggio di errore.

...
Quando seguono ulteriori argomenti della riga di comando , sono raccolti (come
stringhe) insieme a nel vettore ARGV a cui si può accedere da
entro arib. Esempio: se chiami arib con la riga di comando

aribas startup 4536 eisenstein

e la directory corrente contiene il file startup.ari, quindi arib lo carica e
il vettore ARGV ha la forma

==> ARGV.
-: ("avvio", "4536", "eisenstein")

Se hai bisogno di alcuni argomenti come numeri e non come stringhe, puoi trasformarli con
il tuo (o atof); nel nostro esempio

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

lo farà. La lunghezza del vettore ARGV può essere determinato da lunghezza (ARGV).

JOGGING vs RUNNING ARIBA ENTRO EMACS

Puoi correre arib dall'interno di Emacs dando il comando (nel minibuffer di Emacs)

Mx run-aribas

(Se non hai una chiave META, usa ESC x invece di Mx) Allora arib verrà caricato in
una finestra Emacs con nome *aribas* e puoi modificare il tuo input in arib con il solito
Comandi Emacs.

Se il tuo input termina con un punto '.' e premi INVIO, viene inviato a arib. Se
tuttavia il tuo input completo non termina con un punto, (ad esempio in risposta a a
readln), l'input viene inviato a arib da Cj (Control-j) o Cc RETURN.

Se si desidera ripetere un input precedente, Mp (o ESC p) scorre indietro attraverso l'input
storia e Mn (o ESC n) scorre in avanti.

Viene inviato un Control-C a arib da Cc Cc (premere Cc due volte).

È anche possibile iniziare arib da Emacs con argomenti da riga di comando. Per questo
scopo il comando

Cu Mx run-aribas

deve essere dato. Poi un prompt

esegui-aribas: aribas

appare nel Minibuffer di Emacs e puoi completare la riga di comando, per esempio

run-aribas: avvio aribas 4536 eisenstein

(vedi sopra).

CONFIGURAZIONE RISORSE

Opzioni per correre arib può essere specificato anche utilizzando un file di configurazione con nome
.arirc. Ariba cerca un file di configurazione nel seguente ordine:

1) la directory corrente
2) la home directory dell'utente

C'è una terza possibilità: puoi definire una variabile d'ambiente ARIRC contenente la
nome del file di configurazione (che può essere diverso da .arirc), incluso il completo
sentiero.

Nel file di configurazione è possibile specificare tutte le opzioni della riga di comando descritte sopra quali
iniziano con un segno -, tuttavia è necessario utilizzare una riga separata per ogni singola opzione. Linee
che iniziano con il carattere # o le righe vuote vengono ignorate. Oltre alle opzioni
descritto sopra, il file di configurazione può contenere arib codice sorgente. Per questo scopo
ci deve essere una riga di lettura

-dentro

Quindi tutto dopo questa riga viene trattato come arib codice sorgente ed eseguito quando arib
è avviato.

L'esistenza di un file di configurazione per arib non esclude la possibilità di dare
argomenti della riga di comando. Se un'opzione (es. l'opzione -m) è specificata sia nel
file di configurazione e la riga di comando ma con valori diversi, quindi la specifica
alla riga di comando è valido. Analogamente, un'opzione -v sulla riga di comando sovrascrive un -q
opzione nel file di configurazione. Se c'è il codice -init nel file di configurazione e an
argomento nella riga di comando, quindi il codice -init viene eseguito per primo e
dopo il viene caricato e il suo codice viene eseguito.

Usa aribas online utilizzando i servizi onworks.net