Provided by: manpages-fr_4.27.0-1_all 
NOM
bc – Un langage de calculatrice à précision arbitraire
SYNTAXE
bc [ -hlwsqv ] [options_longues] [ fichier ... ]
DESCRIPTION
bc est un langage qui prend en charge les nombres en précision arbitraire ainsi qu'une exécution
interactive des instructions. Il y a quelques similitudes au niveau de la syntaxe avec le langage de
programmation C. Une bibliothèque mathématique standard est disponible à l’aide d’options de ligne de
commande. Si nécessaire, la bibliothèque mathématique peut être définie avant de prendre en compte le
moindre fichier. bc démarre en traitant le code de tous les fichiers listés sur la ligne de commande dans
leur ordre d'apparition. Après que tous les fichiers ont été traités, bc lit à partir de l'entrée
standard. Tout le code est exécuté dès qu'il est lu (si un fichier contient une commande indiquant
d'arrêter le processeur, bc ne lira jamais à partir de l'entrée standard).
Cette version de bc contient plusieurs extensions en sus des implémentations traditionnelles de bc et du
document de travail de la norme POSIX. Les options de ligne de commande peuvent faire afficher un
avertissement par ces extensions ou les rejeter. Ce document décrit le langage accepté par ce processeur.
Les extensions seront considérées selon cela.
OPTIONS
-h, --help
Afficher ce message et quitter.
-i, --interactive
Forcer le mode interactif.
-l, --mathlib
Définir la bibliothèque mathématique standard.
-w, --warn
Émettre des avertissements pour les extensions du bc POSIX.
-s, --standard
Utiliser exactement le langage bc POSIX.
-q, --quiet
Ne pas afficher le message normal de bienvenue de GNU bc.
-V, --version
Afficher le numéro de version et le copyright et quitter.
NOMBRES
L'élément le plus basique dans bc est le nombre. Les nombres sont des nombres en précision arbitraire.
Cette précision vaut à la fois pour la partie entière et pour la partie fractionnaire. Tous les nombres
sont représentés de façon interne en décimal et tous les calculs sont effectués en décimal (cette version
tronque les résultats des opérations de division et de multiplication). Les nombres ont deux attributs :
la longueur et l'échelle. La longueur est le nombre total de chiffres décimaux utilisés par bc pour
représenter un nombre et l'échelle est le nombre total de chiffres décimaux après le point décimal. Par
exemple :
.000001 a une longueur de 6 et une échelle de 6.
1935.000 a une longueur de 7 et une échelle de 3.
VARIABLES
Les nombres sont stockés dans deux types de variables : les variables simples et les variables de
tableau. Toutes deux sont nommées. Les noms commencent par une lettre suivie d'un nombre quelconque de
lettres, de chiffres ou de caractères de soulignement (« _ »). Toutes les lettres doivent être en
minuscule. Les noms entièrement alphanumériques sont une extension. Dans le bc POSIX, tous les noms sont
constitués d'une seule lettre minuscule. Le type de variable est rendu évident grâce au contexte, car
tous les noms de variables de tableau sont suivis de crochets ([]).
Il y a quatre variables spéciales : scale, ibase, obase et last. scale définit la façon dont certaines
opérations utilisent les chiffres après le point décimal. La valeur par défaut pour scale est 0. ibase et
obase définissent la base de conversion pour les nombres en entrée et en sortie. La base par défaut
est 10, que ce soit pour l'entrée ou pour la sortie. last (une extension) est une variable ayant pour
valeur le dernier nombre affiché. Ces variables seront commentées plus en détail quand cela sera
approprié. Toutes ces variables peuvent se voir affecter des valeurs et être utilisées dans des
expressions.
COMMENTAIRES
Les commentaires dans bc débutent par les caractères /* et se terminent par les caractères */. Les
commentaires peuvent démarrer n'importe où et apparaître comme une simple espace en entrée. Cela conduit
les commentaires à délimiter les autres éléments de l'entrée. Par exemple, un commentaire ne peut être
trouvé au milieu d'un nom de variable. Les commentaires incluent tous les sauts de ligne (fin de ligne)
situés entre le début et la fin du commentaire.
Pour que bc prenne en charge l'utilisation de scripts, un commentaire d'une seule ligne a été ajouté
comme extension. Un commentaire d'une seule ligne débute par un caractère # et continue jusqu'à la fin de
la ligne. Le caractère de fin de ligne ne fait pas partie du commentaire et est traité normalement.
EXPRESSIONS
Les nombres sont manipulés par des expressions et des instructions. Puisque le langage a été conçu pour
être interactif, les instructions et les expressions sont exécutées le plus tôt possible. Il n'y a pas de
programme « main ». Au lieu de cela, le code est exécuté dès qu'il est rencontré. Les fonctions,
expliquées en détail ci-après, sont définies quand elles sont rencontrées.
Une expression simple est simplement une constante. bc convertit les constantes en nombres décimaux
internes en utilisant la base courante de l’entrée courante, spécifiée par la variable ibase. Une
exception existe pour les fonctions. Les valeurs valables pour ibase vont de 2 à 36, celles supérieures
à 16 sont une extension. Affecter une valeur en dehors de cet intervalle à ibase résultera en une valeur
de 2 ou 36. Les nombres d'entrée peuvent contenir les caractères 0-9 et A-F (remarque : ils doivent être
en capitales, les lettres minuscules étant des noms de variables). Les nombres d'un seul chiffre ont
toujours la valeur de ce chiffre quelle que soit la valeur de ibase (c’est-à-dire A = 10). Pour les
nombres composés de plusieurs chiffres, bc remplace tous les chiffres d'entrée supérieurs ou égaux à
ibase par la valeur de ibase - 1. Cela fait en sorte que le nombre ZZZ est toujours le plus grand nombre
de 3 chiffres dans la base d'entrée.
Les expressions complètes sont similaires à celles de nombreux autres langages de haut niveau. Puisqu'il
n'y a qu'un seul type de nombre, il n'y a pas de règle pour mélanger des types. Au lieu de cela, il
existe des règles portant sur l'échelle des expressions. Chaque expression possède une échelle. Elle est
dérivée de l'échelle des nombres originaux, de l'opération effectuée et, dans de nombreux cas, de la
valeur de la variable scale. Les valeurs valables pour la variable scale vont de 0 au plus grand nombre
représentable par un entier C.
Dans les descriptions suivantes des expressions valables, « expr » fait référence à une expression
complète, et « var » à une variable simple ou de tableau. Une variable simple est juste un
nom
et une variable de tableau est indiquée par
nom[expr]
À moins qu'elle ne soit mentionnée spécifiquement, l'échelle du résultat est la plus grande de celles des
expressions impliquées.
- expr Le résultat de la négation de l'expression.
++ var La variable est incrémentée de un et la nouvelle valeur est le résultat de l'expression.
-- var La variable est décrémentée de un et la nouvelle valeur est le résultat de l'expression.
var ++
Le résultat de l'expression est la valeur de la variable et ensuite la variable est incrémentée
de un.
var -- Le résultat de l'expression est la valeur de la variable et ensuite la variable est décrémentée de
un.
expr + expr
Le résultat de l'expression est la somme des deux expressions.
expr - expr
Le résultat de l'expression est la différence des deux expressions.
expr * expr
Le résultat de l'expression est le produit des deux expressions.
expr / expr
Le résultat de l'expression est le quotient des deux expressions. L'échelle du résultat est la
valeur de la variable scale.
expr % expr
Le résultat de l'expression est le « reste » et il est calculé de la manière suivante : pour
calculer a%b, a/b est d'abord calculé avec une échelle de scale chiffres. Ce résultat est utilisé
pour calculer a-(a/b)*b avec comme échelle le maximum de scale + échelle(b) et échelle(a). Si
scale vaut zéro et que les deux expressions sont des entiers, cette expression est la fonction
modulo d’entiers.
expr ^ expr
Le résultat de l'expression est la valeur de l’élévation de la première expression à une puissance
égale à la valeur de la seconde expression. La seconde expression doit être un entier. Si la
seconde expression n'est pas un entier, un avertissement est généré et l'expression est tronquée
pour obtenir une valeur entière. L'échelle du résultat est scale si l'exposant est négatif. Si
l'exposant est positif, l'échelle du résultat est le minimum entre l'échelle de la première
expression multipliée par la valeur de l'exposant et celle maximale entre scale et l'échelle de la
première expression (par exemple, scale(a^b) = min(scale(a)*b, max(scale, scale(a)))). Il faut
noter que expr^0 renverra toujours la valeur 1.
( expr )
Cela altère la priorité standard pour forcer l'évaluation de l'expression.
var = expr
La valeur de l'expression est affectée à la variable.
var <op>= expr
C'est équivalent à « var = var <op> expr » excepté que la partie « var » n'est évaluée qu'une
seule fois. Cela peut faire une différence si « var » est un tableau.
Les expressions relationnelles sont un cas particulier des expressions qui sont toujours évaluées à 0
ou 1 : 0 si la relation est fausse et 1 si la relation est vraie. Elles peuvent apparaître dans n'importe
quelle expression valable. Le bc POSIX requiert que les expressions relationnelles ne soient utilisées
que dans les instructions if, for et while, et qu'un seul test relationnel y soit effectué. Les
opérateurs relationnels sont
expr1 < expr2
Le résultat est 1 si expr1 est strictement inférieure à expr2.
expr1 <= expr2
Le résultat est 1 si expr1 est inférieure ou égale à expr2.
expr1 > expr2
Le résultat est 1 si expr1 est strictement supérieure à expr2.
expr1 >= expr2
Le résultat est 1 si expr1 est supérieure ou égale à expr2.
expr1 == expr2
Le résultat est 1 si expr1 est égale à expr2.
expr1 != expr2
Le résultat est 1 si expr1 n'est pas égale à expr2.
Les opérations booléennes sont également valables. Le bc POSIX NE possède PAS d’opérations booléennes. Le
résultat de toutes les opérations booléennes est 0 ou 1 (pour faux ou vrai) comme dans les expressions
relationnelles. Les opérateurs booléens sont :
!expr Le résultat est 1 si expr vaut 0.
expr && expr
Le résultat est 1 si les deux expressions sont différentes de zéro.
expr || expr
Le résultat est 1 si au moins l'une des deux expressions est différente de zéro.
La priorité dans les expressions est la suivante (de la plus basse à la plus haute) :
opérateur ||, associatif à gauche
opérateur &&, associatif à gauche
opérateur !, non associatif
opérateurs relationnels, associatifs à gauche
opérateur d'affectation, associatif à droite
opérateurs + et - , associatifs à gauche
opérateurs *, / et %, associatifs à gauche
opérateur ^, associatif à droite
opérateur - unaire, non associatif
opérateurs ++ et --, non associatifs
Cette priorité a été choisie de telle sorte que les programmes bc conformes à POSIX s'exécutent
correctement. Cela conduira à ce que l'utilisation des opérateurs relationnels et logiques mène à un
comportement inhabituel lors de leur utilisation dans des expressions d'affectation. Considérez
l'expression :
a = 3 < 5
La plupart des programmeurs C supposeraient que cela affecte le résultat de « 3 < 5 » (la valeur 1) à la
variable « a ». Dans bc, cela affecte la valeur 3 à la variable « a » et compare ensuite 3 à 5. Il vaut
mieux utiliser des parenthèses lors de l'utilisation d'opérateurs relationnels ou logiques en présence
d'opérateurs d'affectation.
Il y a quelques expressions spéciales supplémentaires qui sont fournies dans bc. Elles se rapportent à
des fonctions définies par l'utilisateur et à des fonctions standard. Elles apparaissent toutes sous la
forme « nom(paramètres) ». Consulter la section sur les fonctions pour les fonctions définies par
l'utilisateur. Les fonctions standard sont :
length ( expression )
La valeur de la fonction length est le nombre de chiffres significatifs dans l'expression.
read ( )
La fonction read (une extension) lit un nombre à partir de l'entrée standard indépendamment de
l’endroit où elle est appelée. Attention : cela peut causer des problèmes lors du mélange de
données et d'un programme sur l'entrée standard. Le meilleur usage de cette fonction se situe dans
un programme précédemment écrit qui a besoin d’une saisie de l'utilisateur, mais qui ne permet
jamais que l'utilisateur saisisse du code de programme. La valeur de la fonction read est le
nombre lu à partir de l'entrée standard en utilisant la valeur actuelle de la variable ibase comme
base de conversion.
scale ( expression )
La valeur de la fonction scale est le nombre de chiffres après le point décimal dans l'expression.
sqrt ( expression )
La valeur de la fonction sqrt est la racine carrée de l'expression. Si l'expression est négative,
une erreur d’exécution est générée.
INSTRUCTIONS
Les instructions (comme dans la plupart des langages algébriques) fournissent l’ordre d’évaluation d'une
expression. Dans bc, les instructions sont exécutées « le plus tôt possible ». L'exécution se produit
quand un saut de ligne est rencontré et qu'il y a une ou plusieurs instructions complètes. À cause de
cette exécution immédiate, les sauts de ligne sont très importants dans bc. En fait, le point-virgule et
le saut de ligne sont utilisés comme séparateurs d'instructions. Un saut de ligne mal placé provoquera
une erreur de syntaxe. Puisque les sauts de ligne sont des séparateurs d'instructions, il est possible de
cacher un saut de ligne en utilisant une barre oblique inverse. La séquence « \<nl> », où <nl> est le
saut de ligne, apparaît à bc comme un espace blanc au lieu d'un saut de ligne. Une liste d'instructions
est une série d'instructions séparées par des points-virgules et des sauts de ligne. Voici une liste des
instructions de bc et ce qu'elles font (les éléments entre crochets ([]) sont des parties facultatives de
l'instruction) :
expression
Cette instruction accomplit une des deux actions. Si l'expression débute par « <variable>
<affectation> ... », elle est considérée comme une instruction d'affectation. Si l'expression
n'est pas une instruction d'affectation, l'expression est évaluée et affichée sur la sortie. Après
l’affichage du nombre, un saut de ligne est également affiché. Par exemple, « a=1 » est une
instruction d'affectation et « (a=1) » est une expression qui possède une affectation imbriquée.
Tous les nombres qui sont affichés le sont dans la base spécifiée par la variable obase. Les
valeurs valables pour obase vont de 2 à BC_BASE_MAX (consulter la section LIMITES). Pour les bases
2 à 16, la méthode habituelle d'écriture des nombres est utilisée. Pour les bases supérieures à
16, bc utilise une méthode utilisant des chiffres multicaractères pour afficher les nombres où
chaque chiffre d'une base supérieure est affiché comme un nombre en base 10. Les chiffres
multicaractères sont séparés par des espaces. Chaque chiffre contient le nombre de caractères
requis pour représenter la valeur en base dix de « obase - 1 ». Puisque les nombres sont en
précision arbitraire, certains nombres ne peuvent être affichés sur une seule ligne de sortie. Ces
nombres longs seront éclatés sur plusieurs lignes en utilisant « \ » comme dernier caractère de la
ligne. Le nombre maximal de caractères affichés par ligne est 70. À cause de la nature interactive
de bc, l'affichage d'un nombre présente comme effet de bord l'affectation de la valeur affichée à
la variable spéciale last. Cela permet à l'utilisateur de récupérer la dernière valeur affichée
sans avoir à retaper l'expression qui a affiché le nombre. Affecter une valeur à last est légal et
remplacera la dernière valeur affichée par la valeur affectée. La valeur nouvellement affectée
restera jusqu'à ce que le nombre suivant soit affiché ou qu'une autre valeur soit affectée à last.
Certaines installations peuvent permettre l'utilisation d'un simple point (.) qui ne fait pas
partie d'un nombre comme un raccourci pour last.
string La chaîne de caractères est affichée sur la sortie. Les chaînes débutent par un guillemet double
droit et contiennent tous les caractères présents jusqu'au guillemet suivant. Tous les caractères
sont utilisés littéralement, y compris les sauts de ligne. Aucun caractère de saut de ligne n'est
imprimé après la chaîne.
print liste
L'instruction print (une extension) fournit une autre méthode de sortie. La « liste » est une
liste de chaînes et d'expressions séparées par des virgules. Les chaînes ou expressions sont
affichées dans leur ordre d'apparition dans cette liste. Aucun saut de ligne terminal n'est
affiché. Les expressions sont évaluées et leur valeur est affichée et affectée à la variable last.
Les chaînes de l'instruction print sont affichées sur la sortie et peuvent contenir des caractères
spéciaux. Les caractères spéciaux débutent par une barre oblique inverse (\). Les caractères
spéciaux reconnus par bc sont « a » (alerte ou sonnerie), « b » (effacement arrière), « f » (saut
de page), « n » (saut de ligne), « r » (retour chariot), « q » (guillemet double droit), « t »
(tabulation) et « \ » (barre oblique inverse). Tout autre caractère suivant la barre oblique
inverse sera ignoré.
{ liste_instructions }
C'est l'instruction composée. Elle permet à plusieurs instructions d'être regroupées pour
exécution.
if ( expression ) instruction1 [else instruction2]
L'instruction if évalue l'expression et exécute instruction1 ou instruction2 en fonction de la
valeur de l'expression. Si l'expression est différente de zéro, instruction1 est exécutée. Si
instruction2 est présente et que la valeur de l'expression est 0, alors instruction2 est exécutée
(la clause else est une extension).
while ( expression ) instruction
L'instruction while exécutera l'instruction tant que l'expression est différente de zéro. Elle
évalue l'expression avant chaque exécution de l'instruction. La fin de la boucle est causée par
une valeur d'expression de 0 ou par l'exécution d'une instruction break.
for ( [expression1] ; [expression2] ; [expression3] ) instruction
L'instruction for contrôle l'exécution répétée de l'instruction. Expression1 est évaluée avant la
boucle. Expression2 est évaluée avant chaque exécution de l'instruction. Si elle est différente de
zéro, l'instruction est évaluée. Si c’est zéro, la boucle est terminée. Après chaque exécution de
l'instruction, expression3 est évaluée avant la réévaluation de expression2. Si expression1 ou
expression3 sont absentes, rien n'est évalué au moment où elles devraient l'être. Si expression2
manque, cela revient à substituer la valeur 1 à expression2. Les expressions facultatives sont une
extension. Le bc POSIX requiert les trois expressions. Le code suivant est équivalent à
l'instruction for :
expression1;
while (expression2) {
instruction;
expression3;
}
break Cette instruction provoque un arrêt forcé de l'instruction while ou for englobante la plus proche.
continue
L'instruction continue (une extension) force l'instruction for englobante la plus proche à
commencer l'itération suivante.
halt L'instruction halt (une extension) est une instruction exécutée qui indique au processeur bc de ne
s'arrêter que lorsqu'elle est exécutée. Par exemple, « if (0 == 1) halt » n'obligera pas bc à se
terminer, car le halt n'est pas exécuté.
return Renvoyer la valeur 0 à partir d'une fonction (consulter la section sur les fonctions).
return ( expression )
Renvoyer la valeur de l'expression à partir d'une fonction (consulter la section sur les
fonctions). Comme extension, les parenthèses ne sont pas requises.
PSEUDO-INSTRUCTIONS
Ces instructions ne sont pas des instructions au sens traditionnel du terme. Elles ne sont pas des
instructions exécutées. Leur fonction est effectuée au moment de la compilation.
limits Afficher les limites locales imposées par la version locale de bc. C'est une extension.
quit Quand l'instruction quit est lue, le processeur bc est arrêté, quel que soit l'emplacement de
l'instruction quit. Par exemple, « if (0 == 1) quit » provoquera l'arrêt de bc.
warranty
Afficher une notice de garantie plus longue. C'est une extension.
FONCTIONS
Les fonctions fournissent une méthode pour définir un calcul pouvant être exécuté ultérieurement. Les
fonctions de bc calculent toujours une valeur et la renvoient à l'appelant. Les définitions de fonction
sont « dynamiques » dans le sens où une fonction n'est pas définie avant que sa définition ait été
rencontrée en entrée. Cette définition est ensuite utilisée jusqu'à ce qu'une définition de fonction de
même nom soit rencontrée. La nouvelle définition remplace ensuite l'ancienne. Une fonction est définie
comme suit :
define nom ( paramètres ) { saut_de_ligne liste_auto liste_instructions }
Un appel de fonction est simplement une expression de la forme « nom(paramètres) ».
Les paramètres sont des nombres ou des tableaux (une extension). Dans la définition de fonction, zéro
paramètres ou plus sont définis en fournissant leurs noms séparés par des virgules. Tous les paramètres
sont passés par valeur. Les tableaux sont spécifiés dans la définition des paramètres par la notation
« nom[] ». Dans l'appel de fonction, les paramètres réels sont des expressions complètes pour les
paramètres nombres. La même notation est utilisée pour passer des tableaux et pour définir des paramètres
de tableau. Le tableau nommé est passé par valeur à la fonction. Puisque les définitions de fonctions
sont dynamiques, le nombre de paramètres et leur type sont vérifiés quand une fonction est appelée. Toute
erreur dans le nombre ou le type des paramètres provoquera une erreur à l'exécution. Une erreur à
l'exécution se produit également lors de l'appel d'une fonction non définie.
La liste_auto est une liste facultative de variables destinées à une utilisation « locale ». La syntaxe
de la liste_auto (si elle est présente) est « auto nom, ... ; », le point-virgule étant facultatif.
Chaque nom est le nom d'une variable automatique. Les tableaux peuvent être spécifiés en utilisant la
même notation que celle utilisée pour les paramètres. Ces variables voient leur valeur empilée au début
de la fonction. Les variables sont ensuite initialisées à zéro et utilisées tout au long de l'exécution
de la fonction. À la sortie de la fonction, ces valeurs sont dépilées afin que leur valeur originale (au
moment de l'appel de la fonction) soit restaurée. Les paramètres sont réellement des variables
automatiques qui sont initialisées à une valeur fournie dans l'appel de fonction. Les variables
automatiques sont différentes des variables locales traditionnelles car, si une fonction A appelle une
fonction B, B peut accéder aux variables automatiques de A en utilisant simplement le même nom, à moins
que la fonction B en ait fait des variables automatiques. Étant donné que les variables automatiques et
les paramètres sont placés sur une pile, bc prend en charge les fonctions récursives.
Le corps de la fonction est une liste d'instructions de bc. À nouveau, les instructions sont séparées par
des points-virgules ou des sauts de ligne. Les instructions return provoquent l'arrêt d’une fonction et
le renvoi d'une valeur. Il y a deux versions de l'instruction return. La première forme, « return »,
renvoie la valeur 0 à l'expression appelante. La seconde forme, « return (expression ) », calcule la
valeur de l'expression et la renvoie à l'expression appelante. Il y a un « return (0) » implicite à la
fin de chaque fonction. Cela permet à une fonction de se terminer et de renvoyer 0 sans avoir besoin
d'une instruction return explicite.
Les fonctions modifient également l'utilisation de la variable ibase. Toutes les constantes dans le corps
de la fonction seront converties en utilisant la valeur de ibase au moment de l'appel de fonction. Les
changements d'ibase seront ignorés durant l'exécution de la fonction sauf pour la fonction standard read,
qui utilise toujours la valeur actuelle de ibase pour les conversions de nombres.
Plusieurs extensions ont été ajoutées aux fonctions. D’abord, le format de la définition a été rendu
légèrement moins astreignant. La norme requiert que l'accolade d'ouverture soit placée sur la même ligne
que le mot-clé define et que toutes les autres parties se situent sur les lignes suivantes. Cette version
de bc permet un nombre quelconque de sauts de ligne avant et après l'accolade d'ouverture de la fonction.
Par exemple, les définitions suivantes sont valables :
define d (n) { return (2*n); } define d (n) { return (2*n); }
Les fonctions peuvent être définies comme void. Une fonction void ne renvoie aucune valeur et par
conséquent ne peut être utilisée dans toute place nécessitant une valeur. Une fonction void ne produit
aucune sortie lorsqu’appelée par elle-même sur une ligne d’entrée. Le mot-clé void est placé entre le
mot-clé define et le nom de fonction. Par exemple, en considérant la session suivante :
define py (y) { print "--->", y, "<---", "\n"; } define void px (x) { print "--->", x, "<---", "\n"; } py(1) --->1<--- 0 px(1) --->1<---
Puisque py n’est pas une fonction void, l’appel de py(1) affiche la sortie désirée et une seconde ligne
qui est la valeur de la fonction. Puisque la valeur d’une fonction qui n’a pas reçu d’instruction return
explicite est zéro, celui-ci est affiché. Pour px(1), aucun zéro n’est affiché parce que la fonction est
une fonction void.
L’appel par variable a été aussi ajouté pour les tableaux. Pour déclarer un appel par variable, la
déclaration du paramètre de tableau dans la définition de fonction ressemble à « *nom[] ». L’appel de la
fonction reste le même que l’appel par tableaux de valeurs.
BIBLIOTHÈQUE MATHÉMATIQUE
Si bc est invoqué avec l'option -l, une bibliothèque mathématique est préchargée et l'échelle par défaut
est fixée à 20. Les fonctions mathématiques calculeront leur résultat à l'échelle établie au moment de
leur appel. La bibliothèque mathématique définit les fonctions suivantes :
s (x) Le sinus de x ; x est exprimé en radians.
c (x) Le cosinus de x ; x est exprimé en radians.
a (x) L’arc tangente de x ; arctan renvoie des radians.
l (x) Le logarithme naturel (népérien) de x.
e (x) La fonction exponentielle de e à la puissance x.
j (n,x)
La fonction de Bessel d’ordre entier n de x.
EXEMPLES
Dans /bin/sh, le code suivant affectera la valeur de « pi » à la variable d’interpréteur pi.
pi=$(echo "scale=10; 4*a(1)" | bc -l)
Le code suivant est la définition de la fonction exponentielle utilisée dans la bibliothèque
mathématique. Cette fonction est écrite en bc POSIX.
scale = 20
/* Utilisation du fait que e^x = (e^(x/2))^2 Quand x est suffisamment petit, la série suivante est utilisée : e^x = 1 + x + x^2/2! + x^3/3! + ... */
define e(x) { auto a, d, e, f, i, m, v, z
/* Vérification du signe de x. */ if (x<0) { m = 1 x = -x }
/* Précondition x. */ z = scale; scale = 4 + z + .44*x; while (x > 1) { f += 1; x /= 2; }
/* Initialisation des variables. */ v = 1+x a = x d = 1
for (i=2; 1; i++) { e = (a *= x) / (d *= i) if (e == 0) { if (f>0) while (f--) v = v*v; scale = z if (m) return (1/v); return (v/1); } v += e } }
Le code suivant utilise les fonctionnalités avancées de bc pour implémenter un programme simple de calcul
des soldes de chéquier. Ce programme est conservé de préférence dans un fichier pour qu'il puisse être
réutilisé à maintes reprises sans avoir à le retaper à chaque fois.
scale=2 print "\nProgramme de chéquier !\n" print " Rappelez-vous, les dépôts sont des transactions négatives.\n" print " Quittez par une transaction 0.\n\n"
print "Solde initial ? "; bal = read() bal /= 1 print "\n" while (1) { "solde actuel = "; bal "transaction ? "; trans = read() if (trans == 0) break; bal -= trans bal /= 1 } quit
Le code suivant est la définition de la fonction factorielle récursive :
define f (x) { if (x <= 1) return (1); return (f(x-1) * x); }
OPTIONS READLINE ET LIBEDIT
GNU bc peut être compilé (à l’aide d’une option de configuration) pour utiliser soit la bibliothèque
d'éditeur d'entrée GNU readline, soit la bibliothèque BSD libedit. Cela permet à l'utilisateur d'éditer
des lignes avant de les envoyer à bc. Cela permet également un historique des lignes précédemment tapées.
Quand cette option est sélectionnée, bc possède une variable spéciale supplémentaire. Cette variable
spéciale, history, est le nombre de lignes d'historique mémorisées. Pour readline, une valeur de -1
signifie qu'un nombre illimité de lignes d'historique sont mémorisées. Fixer la valeur de history à un
nombre positif restreint le nombre de lignes d'historique au nombre fourni. La valeur 0 désactive cette
fonctionnalité d'historique. La valeur par défaut est 100. Pour plus d'informations, lisez les manuels
d'utilisateur des bibliothèques GNU readline et history, et BSD libedit. Il n’est pas possible d’activer
à la fois readline et libedit.
DIFFÉRENCES
Cette version de bc a été implémentée sur la base du document de travail POSIX P1003.2/D11 et contient
plusieurs différences et extensions par rapport au document de travail et aux implémentations
traditionnelles. Elle n'a pas été implémentée de la façon traditionnelle en utilisant dc(1). Cette
version est un unique processus qui analyse et exécute une traduction en code intermédiaire (byte code)
du programme. Il y a une option « non documentée » (-c) qui fait émettre par le programme le code
intermédiaire sur la sortie standard au lieu de l'exécuter. Elle a été principalement utilisée pour
déboguer l'analyseur syntaxique et pour préparer la bibliothèque mathématique.
Une source majeure de différences est constituée par les extensions, où une fonctionnalité est étendue
pour offrir plus de fonctionnalités et des ajouts pour de nouvelles fonctionnalités. Voici la liste des
différences et des extensions :
environnement LANG
Cette version ne se conforme pas à la norme POSIX en ce qui concerne le traitement de la variable
d'environnement LANG et de toutes les variables d'environnement dont le nom débute par LC_.
noms Les bc traditionnel et POSIX ont des noms composés d'une seule lettre pour les fonctions, les
variables et les tableaux. Ils ont été étendus pour gérer les noms multicaractères débutant par
une lettre et pouvant contenir des lettres, des nombres et le caractère de soulignement (_).
chaines
Les chaînes de caractères ne peuvent pas contenir d’octet NULL. POSIX dit que tous les caractères
doivent être inclus dans des chaînes.
last Le bc POSIX ne possède pas de variable last. Certaines implémentations de bc utilisent le point
(.) d'une manière similaire.
comparaisons
Le bc POSIX ne permet les comparaisons que dans l'instruction if, l'instruction while et la
seconde expression de l'instruction for. De plus, une seule opération relationnelle est permise
dans chacune de ces instructions.
if instruction, else clause
Le bc POSIX ne possède pas de clause else.
instruction for
Le bc POSIX requiert que toutes les expressions soient présentes dans l'instruction for.
&&, ||, !
Le bc POSIX ne dispose pas des opérateurs logiques.
fonction read
Le bc POSIX ne possède pas de fonction read.
instruction print
Le bc POSIX ne possède pas d'instruction print.
instruction continue
Le bc POSIX ne possède pas d'instruction continue.
instruction return
Le bc POSIX requiert des parenthèses autour de l'expression return.
paramètres de tableau
Le bc POSIX ne gère (actuellement) pas totalement les paramètres tableau. La grammaire POSIX
autorise les tableaux dans les définitions de fonction, mais ne fournit pas de méthode pour
spécifier un tableau comme paramètre réel. C'est plus que probablement un oubli dans la grammaire.
Les implémentations traditionnelles de bc ne gèrent que les paramètres tableau par valeur.
format de fonction
Le bc POSIX requiert que l'accolade ouvrante soit sur la même ligne que le mot-clé define et que
l'instruction auto soit sur la ligne suivante.
=+, =-, =*, =/, =%, =^
Le bc POSIX ne requiert pas la définition de ces opérateurs d'affectation dans « l’ancien style ».
Cette version peut permettre ces affectations dans « l’ancien style ». Utilisez l'instruction
limits pour voir si la version installée les prend en charge. Si elle gère les opérateurs
d'affectation dans « l’ancien style », l'instruction « a = -1 » décrémentera a de 1 au lieu de
fixer a à la valeur -1.
espaces dans les nombres
D'autres implémentations de bc permettent les espaces dans les nombres. Par exemple, « x=1 3 »
affecterait la valeur 13 à la variable x. La même instruction causerait une erreur de syntaxe dans
cette version de bc.
erreurs et exécution
Cette implémentation se différencie des autres implémentations par le code qui est exécuté quand
des erreurs de syntaxe ou d'autres erreurs sont détectées dans le programme. Si une erreur de
syntaxe est trouvée dans une définition de fonction, la récupération des erreurs essaie de trouver
le début d'une instruction et continue à analyser la fonction. Une fois qu'une erreur de syntaxe
est trouvée dans la fonction, la fonction ne sera pas appelable et devient non définie. Les
erreurs de syntaxe dans le code d'exécution interactive invalideront le bloc d'exécution courant.
Le bloc d'exécution est terminé par une fin de ligne qui apparaît après une séquence complète
d'instructions. Par exemple,
a = 1
b = 2
possède deux blocs d'exécution et
{ a = 1
b = 2 }
en possède un. Toute erreur à l'exécution terminera l'exécution du bloc d'exécution courant. Un
avertissement à l'exécution ne terminera pas l'exécution du bloc d'exécution courant.
Interruptions
Durant une session interactive, le signal SIGINT (habituellement généré par la séquence control-C
sur le terminal) interrompra l'exécution du bloc d'exécution courant. Il provoquera l'affichage
d'une erreur à l'exécution indiquant quelle fonction a été interrompue. Après que toutes les
structures à l'exécution ont été « nettoyées », un message est affiché pour notifier l'utilisateur
que bc est prêt à recevoir des entrées supplémentaires. Toutes les fonctions précédemment définies
le restent, et la valeur de toutes les variables non automatiques est celle ayant cours au moment
de l'interruption. Toutes les variables automatiques et paramètres de fonction sont supprimés
durant le processus de nettoyage. Durant une session non interactive, le signal SIGINT terminera
l'exécution entière de bc.
LIMITES
Voici les limites actuellement en vigueur pour ce processeur bc. Certaines d'entre elles peuvent avoir
été modifiées par une installation. Utilisez l'instruction limits pour voir les valeurs réelles.
BC_BASE_MAX
La base de sortie maximale est actuellement fixée à 999. La base d'entrée maximale est 16.
BC_DIM_MAX
C'est actuellement une limite arbitraire de 65535 dans la distribution. Votre installation peut
être différente.
BC_SCALE_MAX
Le nombre de chiffres après le point décimal est limité à INT_MAX chiffres. Le nombre de chiffres
avant le point décimal est également limité à INT_MAX chiffres.
BC_STRING_MAX
La limite sur le nombre de caractères dans une chaîne est de INT_MAX caractères.
exposant
La valeur de l'exposant dans l'opération d’exponentielle (^) est limitée à LONG_MAX.
noms de variable
Le nombre maximal de noms uniques est fixé à 32767 pour toutes les variables simples, les tableaux
et les fonctions.
VARIABLES D'ENVIRONNEMENT
Les variables d’environnement suivantes sont prises en compte par bc :
POSIXLY_CORRECT
C’est la même chose que l’option -s.
BC_ENV_ARGS
C'est un autre mécanisme pour obtenir des arguments pour bc. Le format est le même que celui des
arguments en ligne de commande. Ces arguments sont traités en premier lieu, de sorte que les
fichiers listés dans les arguments d'environnement sont traités avant n'importe quel fichier
apparaissant comme argument sur la ligne de commande. Cela permet à l'utilisateur de définir des
options et des fichiers « standard » à traiter lors de chaque invocation de bc. Les fichiers
présents dans les variables d'environnement contiennent typiquement des définitions de fonction
pour les fonctions que l'utilisateur veut voir définies à chaque fois que bc est exécuté.
BC_LINE_LENGTH
Cela doit être un entier spécifiant le nombre de caractères dans une ligne de sortie pour les
nombres. Cela inclut les caractères de barre oblique inversée et de saut de ligne pour les nombres
longs. Comme extension, la valeur zéro désactive la fonctionnalité multiligne. Toute autre valeur
de cette variable inférieure à trois définit la longueur de ligne à 70.
DIAGNOSTICS
Si l'un des fichiers de la ligne de commandes ne peut être ouvert, bc indiquera que le fichier n'est pas
disponible et se terminera. Il y a également des diagnostics lors de la compilation et de l'exécution qui
devraient être suffisamment auto-explicites.
BOGUES
La récupération après erreur n'est pas encore très bonne.
Envoyez vos rapports de bogues par courriel à bug-bc@gnu.org. Assurez-vous d'inclure le mot « bc »
quelque part dans le champ « Sujet : ».
AUTEUR
Philip A. Nelson
philnelson@acm.org
REMERCIEMENTS
L'auteur veut remercier Steve Sommars (Steve.Sommars@att.com) pour son aide intensive lors des tests de
l'implémentation. Il a fourni beaucoup de suggestions géniales. C'est un produit bien meilleur grâce à
son implication.
TRADUCTION
La traduction française de cette page de manuel a été créée par Frédéric Delanoy <delanoy_f@yahoo.com> et
Jean-Paul Guillonneau <guillonneau.jeanpaul@free.fr>
Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General Public License
version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.
Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à
debian-l10n-french@lists.debian.org.
Projet GNU 11 juin 2006 bc(1)