aribas - En ligne dans le Cloud

PROGRAMME:

Nom

aribas - Interprète arithmétique multiprécision

SYNOPSIS

aribas [Options] [fichier ari> [argument1>argument2> ...]]

Cette page de manuel a été écrite pour Debian car le logiciel d'origine ne contenait pas de man
.

DESCRIPTION

Aribas est un interpréteur interactif adapté à l'arithmétique des grands entiers et
arithmétique à virgule flottante multiprécision. Il a une syntaxe similaire à Pascal ou Modula-2,
mais contient également des fonctionnalités d'autres langages de programmation comme C, Lisp, Oberon.

UTILISATION

La façon la plus simple d'utiliser aribas est comme une calculatrice pour l'arithmétique (grand entier). Après
aribas est démarré, il affiche une invite ==> et est prêt à accepter l'entrée. Entrez simplement le
l'expression que vous souhaitez calculer, suivie d'un point, puis appuyez sur RETOUR, pour
exemple

==> 123 + 456*789.

Aribas réponses

- : 359907

Le symbole -: présente le résultat.
IMPORTANT. Pour marquer la fin de votre saisie, vous devez toujours taper un point '.' puis
appuyez sur RETOUR.

Vous pouvez affecter le résultat d'un calcul à une variable, comme dans

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

Ceci calcule le 6ème nombre de Fermat (** dénote une exponentiation) et l'affecte au
variable F6 (Notez que aribas est sensible à la casse, ce n'est donc pas la même chose que f6). Plus tard
vous pouvez utiliser cette variable par exemple dans l'expression

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

ce qui montre (par le théorème de Fermat) que F6 n'est pas un nombre premier.
Les trois résultats les plus récents sont stockés dans les pseudo variables _, __et ___. For
exemple vous pouvez stocker le dernier résultat dans la variable x par la commande

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

Comme vous pouvez le voir dans les exemples ci-dessus, aribas utilise le trait de soulignement _ pour structurer la sortie
de grands entiers (>= 2**32). Aussi pour la saisie d'entiers, vous pouvez utiliser le trait de soulignement, le
la seule condition est qu'immédiatement avant et après le trait de soulignement il y ait des chiffres,
Exemple:

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

Ici, la sortie ne contient aucun trait de soulignement, ce qui montre que z est inférieur à 2**32.

Aribas a plusieurs fonctions intégrées pour la factorisation, par exemple rho_factoriser, Qui
utilise l'algorithme rho de Pollard.

==> rho_factorize(F6).

travail ..
facteur trouvé après 512 itérations

- : 274177

Pour trouver le cofacteur restant, donnez la commande

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

Pour tester si ce facteur est premier, le test probabiliste de Rabin rab_primetest peuvent être
appliqué:

==> rab_primetest(x).
-: vrai

La fonction rho_factoriser est bon pour trouver de petits facteurs (disons jusqu'à 10 décimales
chiffres); pour les tâches de factorisation plus compliquées, un algorithme plus puissant comme le
tamis quadratique qs_factoriser Devrait être utilisé

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

(Selon la puissance de votre ordinateur, cela prendra quelques secondes jusqu'à quelques minutes
pour obtenir un facteur premier du 7e nombre de Fermat.)

Control structures
La en boucle et le tout en boucle dans aribas avoir une syntaxe comme dans Modula-2. Par exemple, le
la séquence de commandes suivante calcule la factorielle de 100.

==> x := 1;
pour i: = 2 à 100 do
x := x*je;
fin;
x.

Comme vous pouvez le voir dans cet exemple, l'entrée peut s'étendre sur plusieurs lignes.

Le dessus en boucle est équivalente à la suivante tout en boucle

==> x := 1; je := 2;
alors que je <= 100 faire
x := x*je;
inc (i);
fin;
x.

La construction de branchement
if puis Elsif d'autre fin
a également la même syntaxe que dans Modula-2.

Multiprécision flottant point des fonctions arithmétiques de bases
Aribas prend en charge différents types de nombres à virgule flottante qui sont représentés en interne
avec des mantisses de différentes longueurs de bits :

single_float 32 bits
double_float 64 bits
long_float 128 bits

et plusieurs précisions plus élevées jusqu'à une limite dépendante de l'implémentation, généralement 1024 ou
5120 bits, qui peuvent être déterminés par la fonction max_floatprec(). Par défaut, quand
calcul avec des nombres de type de données réal, single_floats sont utilisés. Cela correspond à un
précision de 9 à 10 décimales. Une précision de 5120 bits correspond à plus de 1500
décimales.

La précision peut être modifiée à l'aide de la fonction set_floatprec. La fonction prend un
argument entier, qui est la précision souhaitée en bits. Il est automatiquement arrondi à
la valeur disponible immédiatement supérieure. Par exemple, après

==> set_floatprec (100).
- : 128

la précision en virgule flottante est de 128 bits et vous pouvez calculer

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

==> _/pi.
-: 0.33333_33333_33333_33333_33333_33333_33333_33

Utilisateur défini fonctions
L'utilisateur peut définir ses propres fonctions. Un exemple typique ressemble à

==> fonction fac(n : entier) : entier ;
var
x,i : entier ;
commencer
x: = 1;
pour i: = 2 to n do
x := x*je;
fin;
renvoie x ;
fin.

Si vous l'avez entré correctement, aribas fait écho au nom de la fonction

- : fac

et à partir de maintenant vous pouvez utiliser fac de la même manière qu'une fonction intégrée, par exemple

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

Notez qu'à l'intérieur des définitions de fonctions, toutes les variables utilisées doivent être explicitement déclarées,
alors qu'au plus haut niveau de la aribas les variables de l'interpréteur peuvent être simplement créées par
affectations. Voici un autre exemple, qui montre d'autres types de données pris en charge par
aribas:

==> fonction sqrt_list(n : entier) : tableau de réels ;
var
vec : tableau[n] de réel ;
i: entier;
commencer
pour i: = 1 to n do
vec[i-1] := sqrt(i);
fin;
retour vec;
fin.

Cette fonction renvoie un tableau des racines carrées des entiers de 1 à n, pour
exemple

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

Dans un projet de programmation plus important où vous avez besoin de plusieurs fonctions, vous ne les saisiriez pas
directement au aribas invite mais prépare les définitions de fonction avec un texte externe
éditeur et enregistrez-les dans un fichier avec l'extension .ari , Par exemple abcd.ari . Ce fichier
peut alors être chargé par aribas en utilisant la commande

==> load("abcd").

S'il y a une erreur de syntaxe dans le fichier, vous obtenez un message d'erreur de la forme

erreur à la ligne <= 23 du fichier chargé
si : fin attendue

qui vous indique (dans cet exemple) qu'il y a une erreur dans le if construire à la ligne 23 ou
plus tôt dans le fichier. (Notez que les messages d'erreur sont parfois peu précis.) Vous
peut alors corriger l'erreur et charger à nouveau le fichier.

aider
La commande

==> symboles(aribas).

renvoie une liste de tous les mots-clés et noms des fonctions intégrées de aribas. Cette liste a
environ 200 entrées, et commence et se termine comme suit :

(ARGV, _, __, ___, abs, alloc et, arccos, arcsin, arctan, arctan2, aribas, array, atof,
atoi, commencer, binaire, bit_and, bit_clear, bit_length, ...... , tolower, toupper,
transcription, true, trunc, type, user, var, version, while, write, write_block, write_byte,
écrire)

Pour la plupart des symboles de cette liste, vous pouvez obtenir une courte aide en ligne en utilisant la fonction
aider(). Par exemple, la commande

==> aide(ARGV).

donne une information sur la variable intégrée ARGV, tandis que

==> aide (pendant que).

décrit la syntaxe du tout en boucle. Si vous avez besoin de plus d'informations que celles contenues
dans l'aide en ligne, consultez la documentation qui se trouve dans /usr/share/doc/aribas.

Comment à sortie
Pour mettre fin à un aribas séance, tapez sortie au aribas rapide

==> sortie

puis appuyez sur la touche RETOUR (ENTRÉE).

Si tu ne veux pas partir aribas, mais que vous voulez sortir d'une boucle infinie ou d'un
calcul qui dure trop longtemps, tapez CONTROL-C (si vous exécutez aribas de l'Intérieur
Emacs, vous devez appuyer deux fois sur CONTROL-C). Cela arrêtera (dans la plupart des cas) le courant
calcul et retour au aribas rapide.

Lorsque vous n'utilisez pas l'interface Emacs mais la version en ligne de commande de aribas, Vous
se retrouvent parfois dans la situation suivante : une ligne précédente contient une erreur de frappe,
mais vous ne pouvez pas revenir à cette ligne pour la corriger. Dans ce cas, vous devez simplement taper un
arrêt complet '.' , suivi de RETOUR. Vous obtiendrez un message d'erreur que vous pouvez en toute sécurité
ignorer, et une nouvelle invite ==> apparaît, vous permettant de réessayer.

COMMAND LINE ARGUMENTS

aribas [Options] [fichier ari> [argument1>argument2> ...]]

Options
Les options suivantes sont disponibles:

-q (mode silencieux) Supprime tous les messages à l'écran (numéro de version, avis de copyright,
etc.) quand aribas a démarré

-v (mode détaillé, par défaut) Ne supprime pas les messages à l'écran lorsque aribas is
commencé.

-c
aribas fait son propre saut de ligne lors de l'écriture à l'écran. Normalement, cela suppose
que l'écran (ou la fenêtre dans laquelle aribas s'exécute) a 80 colonnes. Avec le -c
option, vous pouvez définir un autre nombre, qui doit être compris entre 40 et 160 (en décimal
représentation). Par exemple, si vous exécutez aribas dans une fenêtre Xterm avec 72
colonnes, utilisez l'option -c72 (ou -c 72, l'espace entre -c et le nombre est
optionnel).

-m
Ici est un nombre (en représentation décimale) compris entre 500 et 32000. Ce
le nombre indique combien de kilo-octets de RAM aribas devrait utiliser pour le aribas tas.
La valeur par défaut dépend des options utilisées lorsque aribas a été compilé. Typiquement,
sous UNIX ou LINUX elle est de 6 Mo, correspondant à -m6000

-h of aider fichier>
L'aide en ligne de aribas dépend d'un fichier aribas.hlp qui doit être situé dans
la plage de la variable d'environnement PATH. Si ce n'est pas le cas, vous pouvez spécifier
le chemin exact du fichier d'aide avec l'option -h. Si par exemple le fichier
aribas.hlp est dans le répertoire / Usr / local / lib, utilisez l'option -h / Usr / local / lib
(l'espace après -h n'est pas nécessaire). L'option -h peut également être utilisée si l'aide
le fichier a un nom différent. Si le fichier d'aide s'appelle help-aribas et se trouve dans le
répertoire /home/joe/ari, utilisez -h/home/joe/ari/help-aribas.

Avec un paquet Debian correctement installé de aribas il ne devrait pas être nécessaire de
utilisez cette option.

-p
Avec cette option, vous pouvez spécifier un chemin de recherche pour le chargement des fichiers avec aribas la source
code. peut être soit le chemin (absolu) d'un répertoire, soit
plusieurs chemins séparés par des deux-points. Supposons que vous ayez appelé aribas avec
l'option

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

et que votre répertoire personnel est /home/alice/. Puis la commande

==> load("facteur").

recherchera le fichier factor.ari d'abord dans le répertoire courant, puis dans le
répertoire /usr/local/lib/aribas et enfin dans /home/alice/ari/examples.

-b Mode batch lors du chargement d'un aribas fichier de code source à partir de la ligne de commande, voir
ci-dessous.

Les options à une lettre qui ne nécessitent aucun argument peuvent être fusionnées, par exemple

aribas -q -b

équivaut à

aribas-qb

Plus loin commander en ligne arguments

L'argument de ligne de commande suivant après les options est interprété comme le nom d'un
fichier avec aribas code source. Si le nom du fichier a l'extension .ari, cette
l'extension peut être omise. Le fichier est chargé comme si la commande charge(" ")
avait été donné après le début de aribas au aribas rapide. Si le fichier n'est pas
trouvé dans le répertoire courant, il est recherché dans les répertoires spécifiés par le
-p option. Si l'option -b a été donnée, le fichier est chargé et exécuté.
Après aribas quitte sans afficher son invite. Si le fichier ne peut pas être chargé
complètement à cause d'une erreur, aribas se ferme immédiatement après le message d'erreur.


Lorsque d'autres arguments de ligne de commande suivent , ils sont collectés (comme
chaînes) avec dans le vecteur ARGV auquel on peut accéder depuis
dans les aribas. Exemple : si vous appelez aribas avec la ligne de commande

démarrage d'aribas 4536 eisenstein

et le répertoire courant contient le fichier startup.ari, alors aribas le charge et
le vecteur ARGV A le formulaire

==> ARGV.
- : ("démarrage", "4536", "eisenstein")

Si vous avez besoin d'arguments sous forme de nombres et non de chaînes, vous pouvez les transformer en
Atoi (ou àtof); dans notre exemple

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

le fera. La longueur du vecteur ARGV peut être déterminé par longueur (ARGV).

RUNNING ARABAS DANS EMAC

Tu peux courir aribas depuis Emacs en donnant la commande (dans le mini-tampon d'Emacs)

Mx run-aribas

(Si vous n'avez pas de clé META, utilisez ESC x au lieu de Mx) Ensuite aribas sera chargé dans
une fenêtre Emacs avec le nom *aribas* et vous pouvez modifier votre entrée pour aribas avec l'habituel
commandes Emacs.

Si votre entrée se termine par un point '.' et vous appuyez sur RETOUR, il est envoyé à aribas. Si
cependant votre entrée complète ne se termine pas par un point (par exemple en réponse à un
readln), l'entrée est envoyée à aribas par Cj (Contrôle-j) ou Cc RETOUR.

Si vous souhaitez répéter une entrée précédente, Mp (ou ESC p) revient en arrière dans l'entrée
historique, et Mn (ou ESC n) avance en boucle.

Un Control-C est envoyé à aribas par Cc Cc (appuyez deux fois sur Cc).

Il est également possible de démarrer aribas d'Emacs avec des arguments de ligne de commande. Pour ça
but la commande

Cu Mx run-aribas

doit être donné. Puis une invite

run-aribas : aribas

apparaît dans le Minibuffer d'Emacs et vous pouvez compléter la ligne de commande, par exemple

run-aribas : démarrage d'aribas 4536 eisenstein

(voir au dessus).

CONFIGURATION DOSSIER

Options pour courir aribas peut également être spécifié à l'aide d'un fichier de configuration avec le nom
.arirc. Aribas recherche un fichier de configuration dans l'ordre suivant :

1) le répertoire courant
2) le répertoire personnel de l'utilisateur

Il existe une troisième possibilité : vous pouvez définir une variable d'environnement ARIRC contenant
nom du fichier de configuration (qui peut être différent de .arirc), y compris le
chemin.

Dans le fichier de configuration, vous pouvez spécifier toutes les options de ligne de commande décrites ci-dessus qui
commencer par un signe -, cependant une ligne distincte doit être utilisée pour chaque option. Lignes
commençant par le caractère # ou les lignes vides sont ignorées. En plus des options
décrit ci-dessus, le fichier de configuration peut contenir aribas code source. Dans ce but
il doit y avoir une lecture de ligne

-initialisation

Ensuite, tout ce qui suit cette ligne est traité comme aribas code source et exécuté lorsque aribas
a démarré.

L'existence d'un fichier de configuration pour aribas n'exclut pas la possibilité de donner
arguments de ligne de commande. Si une option (par exemple l'option -m) est spécifiée à la fois dans le
fichier de configuration et la ligne de commande mais avec des valeurs différentes, puis la spécification
à la ligne de commande est valide. De même, une option -v sur la ligne de commande remplace un -q
option dans le fichier de configuration. S'il y a du code -init dans le fichier de configuration et un
argument à la ligne de commande, puis le code -init est exécuté en premier et
après le est chargé et son code exécuté.

Utilisez aribas en ligne à l'aide des services onworks.net