dc − une calculatrice à précision arbitraire

dc [-V] [--version] [-h] [--help] [-e expression] [--expression=expression] [-f fichier_script] [--file=fichier_script] [fichier ...]

Dc est une calculatrice à notation polonaise inversée qui supporte une précision arithmétique illimitée. Elle permet aussi la définition et l’appel de macros. Dc lit normalement l’entrée standard ; si des arguments sont présents, ce sont des fichiers et ils sont lus et exécutés avant de lire l’entrée standard. Toutes les sorties normales utilisent la sortie standard ; toutes les erreurs utilisent le fichier d’erreur standard.

Une calculatrice à notation polonaise inversée stocke des nombres dans une pile. Chaque nombre entré est empilé. Les opérateurs arithmétiques dépilent les arguments puis empilent les résultats.

Pour entrer un nombre dans dc, entrez les chiffres avec un point décimal optionnel. La notation exponentielle n’est pas supportée. Pour saisir un nombre négatif, précédez le nombre de «_». «-» ne peut pas être utilisé car c’est un opérateur binaire utilisé pour la soustraction. Pour entrer deux nombres successivement, séparez-les par une espace ou un retour à la ligne. L’espace et le retour à la ligne n’ont aucune signification particulière.

Dc peut être invoqué avec les options de ligne de commande suivantes :

-V

--version

Affiche la version de dc que vous utilisez et une note de copyright, puis quitte.

-h

--help

Affiche un aide-mémoire des options et une adresse où rapporter les bogues, puis quitte.

-e expression

--expression=expression

Ajoute les commandes dans expression à l’ensemble des commandes qui seront exécutées.

-f fichier_script

--file=fichier_script

Ajoute les commandes contenues dans le fichier fichier_script à l’ensemble des commandes qui seront exécutées.

S’il reste des paramètres, ils seront interprétés comme des noms de fichiers à exécuter. Le nom de fichier - correspond à l’entrée standard. L’entrée standard sera lue si aucun fichier n’est précisé.

p

Affiche la valeur en haut de la pile sans affecter la pile. Un retour à la ligne est affiché après la valeur.

n

Affiche la valeur en haut de la pile, la dépile, mais n’affiche pas de retour à la ligne.

P

Dépile la valeur en haut de la pile. Si c’est une chaîne, elle est affichée sans retour à la ligne. Sinon c’est un nombre, et la partie entière de sa valeur absolue est affichée comme une chaîne d’octets de « base (UCHAR_MAX+1) ». Si l’on suppose que (UCHAR_MAX+1) est égal à 256, (comme c’est le cas sur la plupart des machines où l’octet fait 8 bits), la séquence KSK 0k1/ [_1*]sx d0>x [256~aPd0<x]dsxx sxLKk pourrait aussi accomplir cette fonction, excepté pour l’effet de bord de changer la valeur du registre x.

f

Affiche la pile en entier sans les modifier. C’est une bonne commande à utiliser si vous êtes perdu ou voulez voir l’effet d’une commande.

+

Dépile deux valeurs, les additionne, puis empile le résultat. La précision du résultat n’est déterminée que par la valeur des arguments, ce qui est suffisant pour être exact.

-

Dépile deux valeurs, soustrait la première valeur de la seconde, puis empile le résultat.

*

Dépile deux valeurs, les multiplie, puis empile le résultat. Le nombre de chiffres de la partie fractionnaire dépend de la précision courante et du nombre de chiffres de la partie fractionnaire des deux arguments.

/

Dépile deux valeurs, divise la seconde valeur par la première, puis empile le résultat. Le nombre de chiffres après la virgule est spécifié par la précision courante.

%

Dépile deux valeurs, calcule le reste de la division que la commande / aurait faite, puis empile le résultat. La valeur calculée est la même que celle produite par la séquence Sd dld/ Ld*- .

~

Dépile deux valeurs, divise la seconde valeur par la première, puis empile le quotient, puis le reste. Le nombre de chiffres après la virgule est spécifié par la précision courante. (La séquence SdSn lnld/ LnLd% pourrait aussi accomplir cette fonction, avec une vérification d’erreur légèrement différente.)

^

Dépile deux valeurs, calcule l’exponentielle de la première valeur avec la base donnée par la seconde valeur. La partie fractionnaire de l’exposant est ignorée. Le nombre de chiffres après la virgule est spécifié par la précision courante.

|

Dépile trois valeurs et calcule le modulo d’une exponentielle. La première valeur dépilée est utilisée pour le modulo, elle doit être différente de zéro et entière. La seconde valeur dépilée est l’exposant, elle doit être positive, la partie fractionnaire est ignorée. La troisième valeur dépilée est la base de l’exponentielle, elle doit être entière. Pour des petits nombres, cette commande est l’équivalent de la séquence Sm^Lm%, mais, contrairement à ^, cette commande fonctionne avec des exposants très grands.

v

Dépile une valeur, calcule la racine carrée, et empile le résultat. Le nombre de chiffres après la virgule est spécifié par la précision courante.

La plupart des opérations arithmétiques sont affectées par la « valeur de précision », que vous pouvez établir avec la commande k.RB . La valeur de précision par défaut est zéro, ce qui signifie que toutes les opérations arithmétiques sauf l’addition et la soustraction produisent des résultats entiers.

c

Nettoie la pile en la vidant.

d

Duplique la valeur en haut de la pile, en en produisant une autre copie. Ainsi, « 4d*p » calcule le carré de 4 et l’affiche.

r

Inverse l’ordre des deux valeurs en haut de la pile.

Dc fournit au moins 256 registres de mémoire, chacun nommé d’un simple caractère. Vous pouvez enregistrer un nombre ou une chaîne dans un registre et le retrouver plus tard.

sr

Enlève la valeur du haut de la pile et la stocke dans le registre r.

lr

Copie la valeur dans le registre r et l’empile. Ceci ne modifie pas le contenu de r.

Chaque registre contient aussi sa propre pile. La valeur du registre courant est le haut de la pile de registre.

Sr

Enlève la valeur du sommet de la pile (principale) et l’empile dans la pile du registre r. La valeur précédente du registre devient inaccessible.

Lr

Enlève la valeur du sommet de la pile du registre r et l’empile dans la pile principale. La valeur précédente dans la pile du registre r, s’il y en a une, est maintenant accessible par la commande lr.RB.

Dc a trois paramètres qui contrôlent son fonctionnement : la précision, la base d’entrée et la base de sortie. La précision spécifie le nombre de chiffres décimaux aprés la virgule à conserver dans le résultat de la plupart des opérations arithmétiques. La base d’entrée contrôle l’interprétation des nombres qui sont tapés ; tous les nombres saisis utilisent cette base. La base de sortie est utilisée pour afficher les nombres.

Les bases d’entrée et de sortie sont des paramètres indépendants ; vous pouvez les rendre différents, ce qui peut être utile ou déroutant. La base d’entrée doit être entre 2 et 16 inclus. La base de sortie doit être doit être d’au moins 2. La précision doit être zéro ou plus. La précision se mesure toujours en chiffres décimaux, sans tenir compte des bases d’entrée et de sortie.

i

Prend la valeur du haut de la pile et l’utilise pour fixer la base d’entrée.

o

Prend la valeur du haut de la pile et l’utilise pour fixer la base de sortie.

k

Prend la valeur du haut de la pile et l’utilise pour fixer la précision.

I

Introduit la base d’entrée courante dans la pile.

O

Introduit la base de sortie courante dans la pile.

K

Introduit la précision courante dans la pile.

Dc peut opérer sur des chaînes comme sur des nombres. Les seules choses que vous pouvez faire avec des chaînes est de les afficher et de les exécuter comme macros (ce qui signifie que le contenu des chaînes est traité comme des commandes dc). Tous les registres et la pile peuvent manipuler des chaînes, et dc sait toujours si un objet donné est une chaîne ou un nombre. Certaines commandes comme les opérateurs arithmétiques demandent des nombres pour arguments et affichent une erreur sinon. Les autres commandes peuvent accepter un nombre ou une chaîne ; par exemple, la commande p peut accepter les deux et affiche l’objet selon son type.

[caractères]

Construit une chaîne contenant des caractères (contenus entre les caractères [ et ] ), et l’empile. Par exemple, [foo]P affiche les caractères foo (sans retour à la ligne).

a

Un objet est dépilé. Si c’était un nombre, l’octet de poids faible de ce nombre est converti en une chaîne et empilé. Si au contraire l’objet dépilé était une chaîne, le premier caractère de la chaîne est empilé.

x

Dépile une valeur et l’exécute comme une macro. Normalement, ce doit être une chaîne ; si c’est un nombre, il est simplement remis sur la pile. Par exemple, [1p]x exécute la macro 1p qui empile 1 et affiche 1 sur une ligne séparée.

Les macros sont souvent stockées dans les registres ; [1p]sa stocke une macro pour afficher 1 dans le registre a, et lax invoque cette macro.

>r

Prend deux valeurs dans la pile et les compare en supposant qu’il s’agit de nombres, puis exécute le contenu du registre r comme une macro si le haut de pile est plus grand Ainsi, 1 2>a invoquera le contenu du registre a et 2 1>a ne le fera pas.

!>r

Semblable mais invoque la macro si le haut de pile original n’est pas plus grand que (inférieur ou égal) la seconde valeur.

<r

Semblable mais invoque la macro si le haut de pile original est inférieur.

!<r

Semblable mais invoque la macro si le haut de pile original n’est pas inférieur (supérieur ou égal) à la deuxième valeur.

=r

Semblable mais invoque la macro si les deux nombres tirés sont égaux.

!=r

Semblable mais invoque la macro si les deux nombres dépilés ne sont pas égaux.

?

Lit une ligne du terminal et l’exécute. Cette commande autorise une macro à demander une entrée à l’utilisateur.

q

quitte une macro et aussi la macro qui l’a invoquée. Si appelée depuis le plus haut niveau ou d’une macro qui a été appelée directement du niveau le plus haut, la commande q fera quitter dc.

Q

Prend une valeur dans la pile et l’utilise comme un compte de niveaux d’exécution de macro dont il faut sortir. Ainsi, 3Q quitte trois niveaux. La commande Q ne fera jamais quitter dc.

Z

Prend une valeur dans la pile, calcule le nombre de chiffres qu’elle contient (ou le nombre de caractères si c’est une chaîne) et empile ce nombre.

X

Prend une valeur dans la pile, calcule le nombre de chiffres après la virgule qu’elle contient, et empile ce nombre. Pour une chaîne, la valeur empilée est 0.

z

Empile la profondeur de pile courante : le nombre d’objets sur la pile avant l’exécution de la commande z.RB .

!

Lancera le reste de la ligne comme une commande système. Notez que les commandes !<, !=, et !> sont prioritaires, de telle manière que si vous voulez lancer une commande commençant par <, =, ou >, vous aurez besoin d’ajouter une espace après le !.

#

Interprétera le reste de la ligne comme un commentaire.

:r

Dépile deux valeurs. L’ancienne deuxième valeur de la pile sera stockée dans le tableau r, indexé par l’ancienne valeur du haut de la pile.

;r

Dépile une valeur et l’utilise comme un index dans le tableau r. La valeur sélectionnée est ensuite placée dans la pile.

Notez que chaque instance empilée d’un registre a son propre tableau associée avec elle. Ainsi, 1 0:a 0Sa 2 0:a La 0;ap affichera 1, car le 2 était stocké dans une instance de 0:a empilée plus tard.

Envoyez des rapports de bogues bug-gnu-utils@gnu.org. Assurez-vous d’inclure le mot « dc » quelque part dans le champ « Subject: ».

Nicolas Schodet <schodet@efrei.fr> et Gérard Delafond <gerard@delafond.org> 2001