bc(1)

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 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 variable 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, ainsi qu'ê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 de l’entrée actuelle 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 variable). 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 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 répartis 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 valable 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 étant 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 imprimé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ètre ou plus sont définis en fournissant leurs noms séparés par des virgules. Les nombres sont des paramètres passés uniquement 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 à « *name[] ». 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) {
      "current balance = "; 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 (_).

Chaînes
    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 au moins 10^9. 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 (https://www.gnu.org/licenses/gpl-3.0.html) 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.