.\" -*- coding: UTF-8 -*-
.\"
.\" dc.1 - the *roff document processor source for the dc manual
.\"
.\" This file is part of GNU dc.
.\" Copyright (C) 1994, 1997, 1998, 2000, 2001, 2005, 2006, 2008, 2013, 2016, 2022, 2024, 2025
.\" Free Software Foundation, Inc.
.\"
.\" This program is distributed in the hope that it will be useful,
.\" but WITHOUT ANY WARRANTY; without even the implied warranty of
.\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
.\" GNU General Public License for more details.
.\"
.\" You should have received a copy of the GNU General Public License
.\" along with this program; see the file COPYING.  If not, see
.\" <https://www.gnu.org/licenses/>.
.\"
.\" Permission is granted to copy, distribute and/or modify this document
.\" under the terms of the GNU Free Documentation License, Version 1.2 or
.\" any later version published by the Free Software Foundation; with no
.\" Invariant Sections, with no Front-Cover Texts, and with no Back-Cover
.\" Texts.
.\"
.\"*******************************************************************
.\"
.\" This file was generated with po4a. Translate the source file.
.\"
.\"*******************************************************************
.TH dc 1 "5 janvier 2025" "Projet GNU" 
.ds dc \fIdc\fP
.ds Dc \fIdc\fP
.SH NOM
dc — Une calculatrice de précision arbitraire
.SH SYNOPSIS
dc [\fB\-V\fP] [\fB\-\-version\fP] [\fB\-h\fP] [\fB\-\-help\fP]
   [\fB\-e\fP \fIscript\fP] [\fB\-\-expression\fP=\fIscript\fP]
   [\fB\-f\fP \fIfichier_script\fP] [\fB\-\-file\fP=\fIfichier_script\fP]
   [\fIfichier\fP ...]
.SH DESCRIPTION
.PP
\fBdc\fP est une calculatrice de bureau en notation polonaise inverse qui prend
en charge une arithmétique de précision illimitée. Elle permet aussi de
définir et d’appeler des macros. Normalement, \fBdc\fP lit l’entrée standard ;
si des arguments de commande sont fournis, ce sont des noms de fichier, et
\fBdc\fP en lira et en exécutera le contenu avant de lire l’entrée
standard. Toute sortie normale s’effectue sur la sortie standard ; tout
message d’erreur est envoyé sur la sortie d’erreur.
.PP
Une calculatrice en notation polonaise inverse stocke les nombres sur une
pile. Entrer un nombre le place au sommet de la pile. Les opérations
arithmétiques dépilent les arguments et empilent les résultats.
.PP
Pour entrer un nombre dans \fBdc\fP, tapez les chiffres de 0 à 9 et de A à F
pour représenter les valeurs de zéro à quinze (indépendamment de la base de
l’entrée actuelle), en incluant éventuellement un séparateur unique entre
les parties entière et non entière. La notation exponentielle n’est pas
prise en charge. Pour entrer un nombre négatif, faites le précéder du
caractère de soulignement « _ ». Le signe moins « \- » ne peut pas être
utilisé à cet effet, car il s’agit d’un opérateur binaire utilisé pour la
soustraction. Pour entrer deux nombres successifs, séparez\-les par une
espace ou un retour à la ligne. Ces derniers n’auront aucune signification
en tant que commande.
.SH OPTIONS
\fBdc\fP peut être invoqué avec les options de ligne de commande suivantes :
.TP 
\fB\-V\fP
.TP 
\fB\-\-version\fP
Afficher la version de l’instance de \fBdc\fP en cours d’exécution, une mention
des droits d’auteur, puis quitter.
.TP 
\fB\-h\fP
.TP 
\fB\-\-help\fP
Afficher un message d’utilisation énumérant ces options de ligne de
commande, l’adresse pour l’envoi des rapports de bogue, puis quitter.
.TP 
\fB\-e \fP\fIscript\fP
.TP 
\fB\-\-expression=\fP\fIscript\fP
Ajouter les commandes contenues dans \fIscript\fP au jeu de commandes à
exécuter lors du traitement de l’entrée.
.TP 
\fB\-f \fP\fIfichier_script\fP
.TP 
\fB\-\-file=\fP\fIfichier_script\fP
Ajouter les commandes contenues dans le fichier \fIfichier_script\fP au jeu de
commandes à exécuter lors du traitement de l’entrée.
.TP 
\fB\-\-max\-recursion=\fP\fIprofondeur\fP
Limiter la récursivité à la \fIprofondeur\fP maximale spécifiée (utilisé
principalement pour le débogage).
.PP
Si des arguments autres que les options décrites ci\-avant apparaissent sur
la ligne de commande, ils seront interprétés comme des noms de fichier
d’entrée à traiter. Le nom de fichier « \- » fait référence à l’entrée
standard. Si aucun script ou fichier de script n’est spécifié, c’est
l’entrée standard qui sera traitée.
.SH "Commandes d’affichage"
.TP 
\fBp\fP
Afficher la valeur du sommet de la pile sans modifier cette dernière. Un
retour à la ligne est ajouté après la valeur.
.TP 
\fBn\fP
Afficher la valeur du sommet de la pile tout en la dépilant et sans ajouter
de retour à la ligne après la valeur.
.TP 
\fBP\fP
Dépiler la valeur du sommet de la pile. S’il s’agit d’une chaîne, elle est
simplement affichée sans retour à la ligne final. Sinon il s’agit d’un
nombre et la partie entière de sa valeur absolue est affichée comme une
suite d’octets « base (UCHAR_MAX+1) ». En supposant que (UCHAR_MAX+1) est
égal à 256 (comme c’est le cas sur la plupart des machines avec des
multiplets de 8 bits), la séquence \fBKSK0k1/_1Ss [ls*]Sxd0>x [256~Ssd0<x]dsxxsx[q]Sq[Lsd0>qaPlxx] dsxxsx0sqLqsxLxLK+k\fP pourrait
aussi effectuer cette opération. La complexité du code propre à \fBdc\fP
ci\-avant est en grande partie due au fait que « ~ » traite les caractères en
sens inverse et au souhait de s’assurer que tous les registres finissent par
retrouver leurs états initiaux.
.TP 
\fBf\fP
Afficher la totalité du contenu de la pile
.ig
and the contents of all of the registers,
..
sans modifier quoi que ce soit. C’est une commande utile si vous êtes perdu
ou souhaitez vous faire une idée de l’effet produit par une certaine
commande.
.SH Arithmétique
.TP 
\fB+\fP
Dépiler deux valeurs, en faire la somme et empiler le résultat. La précision
ne dépend que des valeurs des arguments et est suffisamment grande pour un
résultat exact.
.TP 
\fB\-\fP
Dépiler deux valeurs, soustraire la première de la seconde et empiler le
résultat.
.TP 
\fB*\fP
Dépiler deux valeurs, multiplier l’une par l’autre et empiler le
résultat. Le nombre de chiffres après la virgule du résultat dépend de la
valeur de la précision actuelle et du nombre de chiffres après la virgule
des deux arguments.
.TP 
\fB/\fP
Dépiler deux valeurs, diviser la seconde par la première et empiler le
résultat. Le nombre de chiffres après la virgule du résultat dépend de la
valeur de la précision.
.TP 
\fB%\fP
Dépiler deux valeurs, calculer le reste de la division de la seconde par la
première et empiler le résultat. La valeur est la même que celle qui serait
calculée par la séquence \fBSd dld/ Ld*\-\fP .
.TP 
\fB~\fP
Dépiler deux valeurs et diviser la seconde par la première. Empiler tout
d’abord le quotient, puis faire de même avec le reste de la division. Le
nombre de chiffres après la virgule du résultat dépend de la valeur de la
précision. La séquence \fBSdSn lnld/ LnLd%\fP pourrait aussi effectuer cette
opération avec un traitement des erreurs légèrement différent.
.TP 
\fB^\fP
Dépiler deux valeurs et en calculer l’exponentielle en utilisant la première
valeur comme exposant et la seconde comme base. La partie non entière de
l’exposant est ignorée. Le nombre de chiffres après la virgule du résultat
dépend de la valeur de la précision.
.TP 
\fB|\fP
Dépiler trois valeurs et en calculer l’exponentiation modulaire. La première
valeur est la réduction modulaire ; il doit s’agir d’un nombre entier
différent de zéro. La seconde valeur est l’exposant ; il doit s’agir d’un
nombre supérieur ou égal à zéro dont la partie non entière sera ignorée. La
troisième valeur est la base, objet de l’exponentiation, qui doit être un
nombre entier. Pour les petits nombres entiers, la séquence \fBSm^Lm%\fP pourra
effectuer la même opération, mais à la différence de \fB^\fP, cette commande
fonctionnera avec des exposants de grandeur quelconque.
.TP 
\fBv\fP
Dépiler une valeur, en calculer la racine carrée et empiler le résultat. Le
nombre de chiffres après la virgule du résultat dépend de la valeur maximale
de la précision et de la précision de l’argument.
.PP
La plupart des opérations arithmétiques sont affectées par la « valeur de
précision » qui peut être définie à l’aide de la commande \fBk\fP. La valeur de
précision par défaut est zéro ; avec cette valeur, toutes les opérations
arithmétiques, l'addition et la soustraction n’étant pas concernées,
produiront des résultats entiers.
.SH "Contrôle de la pile"
.TP 
\fBc\fP
Vider la pile.
.TP 
\fBd\fP
Dupliquer la valeur au sommet de la pile et en empiler une autre
copie. Ainsi, « 4d*p » calcule 4 au carré et affiche le résultat.
.TP 
\fBr\fP
Inverser l’ordre des deux valeurs du sommet de la pile (les échanger). La
séquence \fBSaSbLaLb\fP permet d’effectuer la même opération.
.TP 
\fBR\fP
Dépiler l'élément du haut de la pile sous forme d'un entier \fIn\fP. Effectuer
une rotation cyclique des \fIn\fP éléments au sommet de la pile dépilée. Si
\fIn\fP est positif, la direction de la rotation fera que l’élément au sommet
de la pile deviendra le second à partir du sommet ; si \fIn\fP est négatif, la
direction de la rotation fera que l’élément au sommet de la pile deviendra
l’élément de rang \fIn\fP à partir du sommet. Si la hauteur de la pile est
inférieure à \fIn\fP, la rotation s’effectuera sur l’ensemble de la pile (dans
la direction appropriée), sans générer de signalement d’erreur.
.SH Registres
.PP
\fBdc\fP fournit au moins 256 registres en mémoire, chacun d’entre eux étant
nommé à l’aide d’un unique caractère. Il est ainsi possible de stocker un
nombre ou une chaîne dans un registre et les retrouver plus tard.
.TP 
\fBs\fP\fIr\fP
Dépiler une valeur et stocker cette dernière dans le registre \fIr\fP.
.TP 
\fBl\fP\fIr\fP
Faire une copie de la valeur stockée dans le registre \fIr\fP et empiler le
résultat. Si le registre n’a pas été initialisé, la valeur copiée
sera 0. Cette opération ne modifie pas le contenu du registre \fIr\fP.
.PP
Chaque registre contient aussi sa propre pile. La valeur actuelle du
registre correspond à la valeur du sommet de la pile du registre.
.TP 
\fBS\fP\fIr\fP
Dépiler la pile principale et placer la valeur obtenue au sommet de la pile
du registre \fIr\fP. La valeur précédente du registre devient inaccessible.
.TP 
\fBL\fP\fIr\fP
Dépiler la pile du registre \fIr\fP et placer la valeur obtenue au sommet de la
pile principale. La valeur précédente de la pile du registre, si elle
existe,  peut maintenant être lue à l’aide de la commande \fBl\fP\fIr\fP.
.ig
.PP
The
\fBf\fR
command prints a list of all registers that have contents stored in them,
together with their contents.
Only the current contents of each register
(the top of its stack)
is printed.
..
.SH Paramètres
.PP
\fBdc\fP possède trois paramètres permettant de contrôler ses opérations : la
précision, la base de l’entrée et la base de la sortie. La précision indique
le nombre de chiffres après la virgule à conserver dans le résultat de la
plupart des opérations. La base de l’entrée contrôle l’interprétation des
nombres entrés ; tous les nombres entrés seront dans cette base. La base de
la sortie contrôle l’affichage des nombres.
.PP
Les bases de l’entrée et de la sortie sont des paramètres distincts ; elles
peuvent être différentes, ce qui peut s’avérer utile ou source de
confusion. La base de l’entrée doit être comprise entre 2 et 16 inclus. La
valeur minimale de la base de la sortie est 2. La valeur minimale de la
précision est 0. Cette dernière est toujours mesurée en chiffres décimaux,
quelles que soient les bases de l’entrée et de la sortie actuelles.
.TP 
\fBi\fP
Dépiler une valeur et l’utiliser pour définir la base de l’entrée.
.TP 
\fBo\fP
Dépiler une valeur et l’utiliser pour définir la base de la sortie.
.TP 
\fBk\fP
Dépiler une valeur et l’utiliser pour définir la précision.
.TP 
\fBI\fP
Empiler la base de l’entrée actuelle.
.TP 
\fBO\fP
Empiler la base de la sortie actuelle.
.TP 
\fBK\fP
Empiler la précision actuelle.
.SH Chaînes
.PP
Comme il peut opérer sur des nombres, \fBdc\fP peut aussi opérer sur des
chaînes, mais de manière limitée. Les seules opérations possibles sur les
chaînes sont l’affichage et l’exécution en tant que macro (ce qui signifie
que le contenu de la chaîne sera traité comme une commande de \fBdc\fP). Tous
les registres et la pile peuvent contenir des chaînes, et \fBdc\fP saura
toujours si un objet donné est un nombre ou une chaîne. Certaines commandes
comme les opérations arithmétiques attendent des nombres comme arguments et
afficheront une erreur si ces derniers sont des chaînes. D’autres commandes
acceptent un nombre ou une chaîne ; par exemple, la commande \fBp\fP accepte
l’un ou l’autre et affichera l’objet en fonction de son type.
.TP 
\fB[\fP\fIcaractères\fP\fB]\fP
Construire une chaîne contenant les \fIcaractères\fP spécifiés (entourés de
crochets ouvrant \fB[\fP et fermant \fB]\fP) et empiler le résultat. Par exemple,
\fB[toto]P\fP affichera la chaîne \fBtoto\fP (sans retour à la ligne).
.TP 
\fBa\fP
Dépiler une valeur. S’il s’agit d’un nombre, son octet de poids faible est
converti en chaîne et le résultat est empilé. Sinon il s’agit d’une chaîne,
et le premier caractère de cette dernière est empilé.
.TP 
\ 
Note : cette commande est obsolète ; voir \fIdc.info\fP pour les détails. Si
vous utilisez la commande \fBa\fP et pensez qu’elle devrait être conservée dans
GNU \fBdc\fP, rédigez un rapport de bogue pour demander son maintien.
.TP 
\fBx\fP
Dépiler une valeur et l’exécuter en tant que macro. Normalement, il doit
s’agir d’une chaîne ; s’il s’agit d’un nombre, il sera simplement empilé à
nouveau. Par exemple, \fB[1p]x\fP exécutera la macro \fB1p\fP qui empile la valeur
\fB1\fP et affiche \fB1\fP sur une ligne séparée.
.PP
Les macros sont le plus souvent stockées dans des registres ; \fB[1p]sa\fP
stocke la macro qui affiche \fB1\fP dans le registre \fBa\fP et \fBlax\fP invoque
cette macro.
.TP 
\fB>\fP\fIr\fP
Dépiler deux valeurs et les comparer en supposant qu’il s’agit de nombres et
en exécutant le contenu du registre \fIr\fP en tant que macro si la première
valeur au sommet de la pile est supérieure à la seconde. Par exemple, \fB1 2>a\fP invoquera le contenu du registre \fBa\fP, alors que \fB2 1>a\fP ne
l’invoquera pas.
.TP 
\fB!>\fP\fIr\fP
Similaire à la commande précédente, à la différence que la macro du registre
\fIr\fP sera invoquée si la première valeur au sommet de la pile n’est pas
supérieure (est inférieure ou égale) à la seconde.
.TP 
\fB<\fP\fIr\fP
Similaire à la commande précédente, à la différence que la macro du registre
\fIr\fP sera invoquée si la première valeur au sommet de la pile est inférieure
à la seconde.
.TP 
\fB!<\fP\fIr\fP
Similaire à la commande précédente, à la différence que la macro du registre
\fIr\fP sera invoquée si la première valeur au sommet de la pile n’est pas
inférieure (est supérieure ou égale) à la seconde.
.TP 
\fB=\fP\fIr\fP
Similaire à la commande précédente, à la différence que la macro du registre
\fIr\fP sera invoquée si les deux nombres dépilés sont égaux.
.TP 
\fB!=\fP\fIr\fP
Similaire à la commande précédente, à la différence que la macro du registre
\fIr\fP sera invoquée si les deux nombres dépilés ne sont pas égaux.
.ig
This can also be validly used to compare two strings for equality.
..
.TP 
\fB?\fP
Lire une ligne depuis le terminal et l'exécuter. Cette commande permet à une
macro de demander une entrée à l’utilisateur.
.TP 
\fBq\fP
Sortir d’une macro et aussi de celle qui l’a invoquée. Si elle est exécutée
au plus haut niveau, ou depuis une macro directement invoquée depuis le plus
haut niveau, la commande \fBq\fP provoquera la terminaison de \fBdc\fP.
.TP 
\fBQ\fP
Dépiler une valeur et l’utiliser comme compteur de niveaux d’exécution de
macro desquels la sortie s’effectuera. Par exemple, \fB3Q\fP sortira de trois
niveaux. La commande \fBQ\fP ne provoquera jamais la terminaison de \fBdc\fP.
.SH "Demande d’état"
.TP 
\fBZ\fP
Dépiler une valeur, calculer le nombre de chiffres décimaux qu’elle comporte
(ou le nombre de caractères s’il s’agit d’une chaîne) et empiler le
résultat. Le nombre de chiffres que comporte un nombre n’inclut \fIpas\fP les
zéros de début, même s’ils apparaissent à la droite du séparateur entre les
parties entière et non entière.
.TP 
\fBX\fP
.\" \-1.
Dépiler une valeur, calculer le nombre de chiffres que comporte sa partie
non entière et empiler le résultat. Dans le cas d’une chaîne, la valeur
empilée sera 0.
.TP 
\fBz\fP
Empiler la hauteur actuelle de la pile : le nombre d’objets que contenait la
pile avant l’exécution de la commande \fBz\fP.
.SH Divers
.TP 
\fB!\fP
Exécuter le reste de la ligne en tant que commande système. Notez que le
traitement des commandes \fB!<\fP, \fB!=\fP et \fB!>\fP est prioritaire, et
que si vous souhaitez exécuter une commande commençant par \fB<\fP, \fB=\fP ou
\fB>\fP, vous devrez ajouter une espace après le « ! ».
.TP 
\fB#\fP
Le reste de la ligne sera considéré comme un commentaire.
.TP 
\fB:\fP\fIr\fP
Dépiler deux valeurs, puis stocker la seconde dans le tableau \fIr\fP avec un
indice égal à la première valeur.
.TP 
\fB;\fP\fIr\fP
Dépiler une valeur et l’utiliser comme indice pour extraire la valeur
correspondante dans le tableau \fIr\fP et empiler le résultat.
.P
Notez que chaque instance d’un registre dans la pile comporte non seulement
sa valeur scalaire (un nombre ou une chaîne), mais aussi un tableau du même
nom. Ainsi, \fB1 0:x 0Sx 2 0:x Lx 0;xp\fP affichera \fB1\fP, car le \fB2\fP a été
stocké à l’indice 0 d’une instance du tableau \fBx\fP qui a été dépilée par la
suite, ce qui a eu pour effet d’exposer à nouveau l’instance de \fBx\fP qui
contient un \fB1\fP à l’indice 0.
.SH "VARIABLES D'ENVIRONNEMENT"
.IP \fIDC_LINE_LENGTH\fP
Cette variable permet de définir la colonne à laquelle les sorties
numériques sont découpées ; la valeur par défaut est 70. Si elle est définie
à 0, le découpage sera désactivé et chaque ligne en sortie sera aussi longue
que nécessaire pour représenter le nombre.
.IP \fIDC_PROMPT\fP
Cette variable permet de définir une invite à utiliser lorsque \fBdc\fP attend
une entrée interactive sur l’entrée standard.
.SH BOGUES
.PP
Envoyez vos rapports de bogue à \fBbug\-dc@gnu.org\fP.
.SH "VOIR AUSSI"
Des informations plus complètes sont disponibles dans \fIdc.info\fP auxquelles
il devrait être possible d’accéder (en fonction de votre installation
locale) en invoquant la commande \fBinfo dc\fP.
.PP
.SH TRADUCTION
La traduction française de cette page de manuel a été créée par
Lucien Gentis <lucien.gentis@univ-lorraine.fr>
.
.PP
Cette traduction est une documentation libre ; veuillez vous reporter à la
.UR https://www.gnu.org/licenses/gpl-3.0.html
GNU General Public License version 3
.UE
concernant les conditions de copie et 
de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.
.PP
Si vous découvrez un bogue dans la traduction de cette page de manuel, 
veuillez envoyer un message à
.MT debian-l10n-french@lists.debian.org
.ME .