bc - En ligne dans le Cloud

PROGRAMME:

Nom

bc - Un langage de calcul de précision arbitraire

SYNTAXE

bc [ -hlwqv ] [options longues] [ filet ]

DESCRIPTION

bc est un langage qui prend en charge les nombres de précision arbitraire avec l'exécution interactive de
déclarations. Il existe des similitudes dans la syntaxe avec le langage de programmation C. UNE
La bibliothèque mathématique standard est disponible via l'option de ligne de commande. Sur demande, la bibliothèque mathématique
est défini avant de traiter les fichiers. bc commence par traiter le code de tous les fichiers
répertoriés sur la ligne de commande dans l'ordre indiqué. Une fois tous les fichiers traités, bc
lit à partir de l'entrée standard. Tout le code est exécuté au fur et à mesure qu'il est lu. (Si un fichier contient un
commande d'arrêt du processeur, bc ne lira jamais à partir de l'entrée standard.)

Cette version de bc contient plusieurs extensions au-delà des traditionnelles bc implémentations et
le projet de norme POSIX. Les options de ligne de commande peuvent amener ces extensions à imprimer un
avertissement ou à rejeter. Ce document décrit la langue acceptée par ce
processeur. Les extensions seront identifiées comme telles.

OPTIONS
-h, --aide
Imprimez l'utilisation et quittez.

-i, --interactif
Forcer le mode interactif.

-l, --mathlib
Définir la bibliothèque mathématique standard.

-w, --avertir
Donner des avertissements pour les extensions à POSIX bc.

-s, --standard
Traiter exactement le POSIX bc la langue.

-q, --calme
N'imprimez pas l'accueil GNU bc normal.

-v, --version
Imprimez le numéro de version et le copyright et quittez.

NOMBRES
L'élément le plus fondamental de bc est le nombre. Les nombres sont des nombres de précision arbitraire.
Cette précision est à la fois dans la partie entière et dans la partie fractionnaire. Tous les nombres sont
représenté en 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.) Il existe deux attributs de
nombres, la longueur et l'échelle. La longueur est le nombre total de décimales significatives
chiffres dans un nombre et l'échelle est le nombre total de chiffres après la virgule
point. 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, des variables simples et des tableaux. Les deux simples
les variables et les variables de tableau sont nommées. Les noms commencent par une lettre suivie d'un nombre
de lettres, de chiffres et de traits de soulignement. Toutes les lettres doivent être en minuscules. (alphanumérique complet
les noms sont une extension. En POSIX bc tous les noms sont une seule lettre minuscule.) Le type
de variable est clair par le contexte car tous les noms de variables de tableau seront suivis de
supports ([]).

Il y a quatre variables spéciales, escalader, iBase, obsolète, et dernier. en échelon définit comment certains
les opérations utilisent des chiffres après la virgule. La valeur par défaut de en échelon est 0. ibase
et obèse définir la base de conversion des nombres d'entrée et de sortie. La valeur par défaut pour les deux
l'entrée et la sortie sont en base 10. dernier (une extension) est une variable qui a la valeur de
dernier numéro imprimé. Ceux-ci seront discutés plus en détail le cas échéant. Tous
ces variables peuvent avoir des valeurs qui leur sont assignées ainsi qu'utilisées dans des expressions.

COMMENTAIRES
Commentaires dans bc commencer par les personnages /* et terminer avec les personnages */. Les commentaires peuvent
commencer n'importe où et apparaître comme un seul espace dans l'entrée. (Cela provoque des commentaires à
délimiter d'autres éléments d'entrée. Par exemple, un commentaire ne peut pas être trouvé au milieu d'un
nom de la variable.) Les commentaires incluent toutes les nouvelles lignes (fin de ligne) entre le début et la fin
du commentaire.

Pour prendre en charge l'utilisation de scripts pour bc, un commentaire d'une seule ligne a été ajouté en tant que
extension. Un commentaire d'une seule ligne commence à un # caractère et continue jusqu'à la fin suivante 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 déclarations. Puisque la langue était
conçus pour être interactifs, les déclarations et les expressions sont exécutées dès que possible.
Il n'y a pas de programme "principal". Au lieu de cela, le code est exécuté au fur et à mesure qu'il est rencontré. (Les fonctions,
discutés en détail plus tard, sont définis lorsqu'ils sont rencontrés.)

Une expression simple n'est qu'une constante. bc convertit les constantes en décimal interne
nombres utilisant la base d'entrée courante, spécifiée par la variable ibase. (Il y a un
exception dans les fonctions.) Les valeurs légales de ibase sont compris entre 2 et 16. Attribution d'une valeur
en dehors de cette plage à ibase donnera une valeur de 2 ou 16. Les nombres d'entrée peuvent contenir
les caractères 0-9 et A-F. (Remarque : elles doivent être en majuscules. Les minuscules sont variables
noms.) Les nombres à un chiffre ont toujours la valeur du chiffre quelle que soit la valeur
of ibase. (c'est-à-dire A = 10.) Pour les nombres à plusieurs chiffres, bc modifie tous les chiffres d'entrée supérieurs ou
égal à ibase à la valeur de ibase-1. Cela rend le nombre FFF être toujours le plus grand 3
numéro de chiffre de la base d'entrée.

Les expressions complètes sont similaires à de nombreux autres langages de haut niveau. Puisqu'il n'y a qu'un
type de nombre, il n'y a pas de règles pour mélanger les types. Au lieu de cela, il existe des règles sur la
échelle des expressions. Chaque expression a une échelle. Ceci est dérivé de l'échelle de
nombres originaux, l'opération effectuée et dans de nombreux cas, la valeur de la variable
en échelon. Valeurs légales de la variable en échelon sont de 0 au nombre maximum représentable par un C
entier.

Dans les descriptions suivantes des expressions légales, « expr » fait référence à une expression complète
et "var" fait référence à une variable simple ou matricielle. Une variable simple n'est qu'un
prénom
et une variable de tableau est spécifiée comme
prénom[expr]
Sauf mention expresse, l'échelle du résultat est l'échelle maximale du
expressions impliquées.

- expr Le résultat est la négation de l'expression.

++ var La variable est incrémentée de un et la nouvelle valeur est le résultat de la
expression.

-- var La variable est décrémentée de un et la nouvelle valeur est le résultat de la
expression.

variable ++
Le résultat de l'expression est la valeur de la variable, puis la variable est
incrémenté de un.

var -- Le résultat de l'expression est la valeur de la variable, puis la variable est
décrémenté de un.

expression + expression
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 de
le résultat est la valeur de la variable en échelon.

expr % expr
Le résultat de l'expression est le "reste" et il est calculé comme suit
manière. Pour calculer a%b, d'abord a/b est calculé à en échelon chiffres. Ce résultat est utilisé
pour calculer a-(a/b)*b à l'échelle du maximum de en échelon+échelle(b) et échelle(a).
If en échelon est mis à zéro et les deux expressions sont des entiers cette expression est la
fonction de reste entier.

expr ^ expr
Le résultat de l'expression est la valeur de la première élevée à la seconde. Les
la deuxième expression doit être un entier. (Si la deuxième 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 en échelon si l'exposant est négatif. Si l'exposant est
positif l'échelle du résultat est le minimum de l'échelle du premier
expression multipliée par la valeur de l'exposant et le maximum de en échelon et l'échelle
de la première expression. (par exemple échelle(a^b) = min(échelle(a)*b, max( escalader,
scale(a))).) Il convient de noter que expr^0 renverra toujours la valeur 1.

(expression)
Cela modifie la priorité standard pour forcer l'évaluation de l'expression.

var = expression
La variable reçoit la valeur de l'expression.

var = expr
Cela équivaut à "var = var expr" à l'exception de la partie "var"
n'est évalué qu'une seule fois. Cela peut faire une différence si "var" est un tableau.

Les expressions relationnelles sont un type spécial d'expression qui évalue toujours à 0 ou 1, 0
si la relation est fausse et 1 si la relation est vraie. Ceux-ci peuvent apparaître dans n'importe quel
expression. (POSIX bc exige que les expressions relationnelles soient utilisées uniquement dans if, while,
et pour les déclarations et qu'un seul test relationnel peut y être fait.)
les opérateurs sont

expr1 < expr2
Le résultat est 1 si expr1 est strictement inférieur à expr2.

expr1 <= expr2
Le résultat est 1 si expr1 est inférieur ou égal à expr2.

expr1 > expr2
Le résultat est 1 si expr1 est strictement supérieur à expr2.

expr1 >= expr2
Le résultat est 1 si expr1 est supérieur ou égal à expr2.

expr1 == expr2
Le résultat est 1 si expr1 est égal à expr2.

expr1 != expr2
Le résultat est 1 si expr1 n'est pas égal à expr2.

Les opérations booléennes sont également légales. (POSIX bc n'a PAS d'opérations booléennes). Les
le résultat de toutes les opérations booléennes est 0 et 1 (pour faux et vrai) comme dans le relationnel
expressions. Les opérateurs booléens sont :

!expr Le résultat est 1 si expr est 0.

expr && expr
Le résultat est 1 si les deux expressions sont différentes de zéro.

expression || expr
Le résultat est 1 si l'une des expressions est différente de zéro.

La priorité de l'expression est la suivante : (du plus bas au plus élevé)
|| opérateur, associatif gauche
&& opérateur, associatif gauche
! opérateur, non associatif
Opérateurs relationnels, associatif gauche
Opérateur d'affectation, droit associatif
Opérateurs + et -, associatif gauche
Opérateurs *, / et %, associatif gauche
^ opérateur, associatif à droite
unaire - opérateur, non associatif
Opérateurs ++ et --, non associatifs

Cette priorité a été choisie pour que la conformité POSIX bc les programmes fonctionneront correctement. Cette
entraînera l'utilisation des opérateurs relationnels et logiques d'avoir un comportement inhabituel
lorsqu'il est utilisé avec des expressions d'affectation. Considérons l'expression :
a = 3 < 5

La plupart des programmeurs C supposeraient que cela attribuerait le résultat de "3 < 5" (la valeur 1) à
la variable "a". Qu'est-ce que cela fait dans bc est d'affecter la valeur 3 à la variable "a" puis
comparer 3 à 5. Il est préférable d'utiliser des parenthèses lors de l'utilisation d'opérateurs relationnels et logiques
avec les opérateurs d'affectation.

Il y a quelques autres expressions spéciales qui sont fournies dans bc. Ceux-ci ont à voir avec
fonctions définies par l'utilisateur et fonctions standard. Ils apparaissent tous comme "prénom(paramètres)".
Voir la section sur les fonctions pour les fonctions définies par l'utilisateur. Les fonctions standards sont :

longueur (expression)
La valeur de la fonction de longueur est le nombre de chiffres significatifs dans le
expression.

lire ( )
La fonction de lecture (une extension) lira un nombre à partir de l'entrée standard,
quel que soit l'endroit où la fonction se produit. Attention, cela peut causer des problèmes avec le
mélange de données et de programme dans l'entrée standard. La meilleure utilisation de cette fonction
est dans un programme déjà écrit qui nécessite une entrée de l'utilisateur, mais ne permet jamais
code de programme à saisir par l'utilisateur. La valeur de la fonction read est la
nombre lu à partir de l'entrée standard à l'aide de la valeur actuelle de la variable ibase
pour la base de conversion.

échelle ( expression )
La valeur de la fonction d'échelle est le nombre de chiffres après la virgule dans
l'expression.

sqrt (expression)
La valeur de la fonction sqrt est la racine carrée de l'expression. Si la
expression est négative, une erreur d'exécution est générée.

ÉTATS
Les déclarations (comme dans la plupart des langages algébriques) fournissent le séquençage de l'expression
évaluation. Dans bc les instructions sont exécutées "dès que possible". L'exécution se produit lorsque
une nouvelle ligne est rencontrée et il y a une ou plusieurs instructions complètes. En raison de ce
exécution immédiate, les sauts de ligne sont très importants dans bc. En fait, à la fois un point-virgule et un
newline sont utilisés comme séparateurs d'instructions. Une nouvelle ligne mal placée provoquera un
erreur de syntaxe. Comme les retours à la ligne sont des séparateurs d'instructions, il est possible de masquer un retour à la ligne
en utilisant le caractère barre oblique inverse. La séquence "\ ", où est la nouvelle ligne apparaît
à bc comme espace au lieu d'une nouvelle ligne. Une liste d'instructions est une série d'instructions
séparés par des points-virgules et des sauts de ligne. Ce qui suit est une liste de bc déclarations et quoi
ils le font : (Les éléments entre crochets ([]) sont des parties facultatives de l'instruction.)

expression
Cette déclaration fait l'une des deux choses. Si l'expression commence par "
...", il est considéré comme une déclaration d'affectation. Si le
expression n'est pas une instruction d'affectation, l'expression est évaluée et imprimée
à la sortie. Une fois le numéro imprimé, une nouvelle ligne est imprimée. Par exemple,
"a=1" est une instruction d'affectation et "(a=1)" est une expression qui a un
mission. Tous les nombres qui sont imprimés sont imprimés dans la base spécifiée par le
variable obèse. Les valeurs légales de obèse sont de 2 à BC_BASE_MAX. (Voir le
section LIMITES.) Pour les bases 2 à 16, la méthode habituelle d'écriture des nombres est
utilisé. Pour les bases supérieures à 16, bc utilise une méthode de chiffres à plusieurs caractères
imprimer les nombres où chaque chiffre de base supérieur est imprimé en tant que nombre de base 10.
Les chiffres à plusieurs caractè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 de précision arbitraire, certains nombres peuvent ne pas être imprimables sur une seule sortie
ligne. Ces longs nombres seront répartis sur les lignes en utilisant le "\" comme dernier
caractère sur une ligne. Le nombre maximum de caractères imprimés par ligne est de 70.
à la nature interactive de bc, l'impression d'un nombre provoque l'effet secondaire de
affecter la valeur imprimée à la variable spéciale dernier. Cela permet à l'utilisateur de
récupérer la dernière valeur imprimée sans avoir à retaper l'expression imprimée
le nombre. Affectation à dernier est légal et écrasera la dernière valeur imprimée
avec la valeur attribuée. La nouvelle valeur attribuée restera jusqu'à la prochaine
le numéro est imprimé ou une autre valeur est attribuée à dernier. (Certaines installations peuvent
permettre l'utilisation d'une seule période (.) qui ne fait pas partie d'un nombre comme une main courte
notation pour pour dernier.)

chaîne La chaîne est imprimée sur la sortie. Les chaînes commencent par un guillemet double
et contenir tous les caractères jusqu'au prochain guillemet double. Tous les personnages
sont pris au pied de la lettre, y compris toute nouvelle ligne. Aucun caractère de nouvelle ligne n'est imprimé après
la chaîne.

impression 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. Chaque chaîne ou
expression est imprimée dans l'ordre de la liste. Aucune nouvelle ligne de fin n'est imprimée.
Les expressions sont évaluées et leur valeur est imprimée et affectée à la variable
dernier. Les chaînes de l'instruction print sont imprimées sur la sortie et peuvent contenir
caractères spéciaux. Les caractères spéciaux commencent par la barre oblique inverse (\).
Les caractères spéciaux reconnus par bc sont "a" (alerte ou cloche), "b" (retour arrière),
"f" (saut de page), "n" (nouvelle ligne), "r" (retour chariot), "q" (guillemets doubles), "t"
(tab) et "\" (barre oblique inverse). Tout autre caractère suivant la barre oblique inverse sera
ignoré.

{ liste_déclaration }
C'est l'énoncé composé. Il permet de regrouper plusieurs déclarations
ensemble pour l'exécution.

if ( expression ) instruction1 [d'autre déclaration2]
L'instruction if évalue l'expression et exécute instruction1 ou instruction2
selon la valeur de l'expression. Si l'expression est non nulle,
instruction1 est exécutée. Si instruction2 est présent et la valeur de l'expression
est 0, alors l'instruction2 est exécutée. (La clause else est une extension.)

tout en énoncé (expression)
L'instruction while exécutera l'instruction tant que l'expression n'est pas nulle.
Il évalue l'expression avant chaque exécution de l'instruction. Résiliation
de la boucle est causée par une valeur d'expression nulle ou l'exécution d'une pause
déclaration.

pour ( [expression1] ; [expression2] ; [expression3] ) instruction
L'instruction for contrôle l'exécution répétée de l'instruction. Expression1 est
évalué avant la boucle. Expression2 est évaluée avant chaque exécution du
déclaration. S'il est différent de zéro, l'instruction est évaluée. S'il est nul, la boucle
est terminé. Après chaque exécution de l'instruction, expression3 est évaluée
avant la réévaluation de expression2. Si expression1 ou expression3 manquent,
rien n'est évalué au point où ils seraient évalués. Si expression2 est
manquant, cela revient à substituer la valeur 1 à expression2. (L'optionnel
les expressions sont une extension. POSIX bc requiert les trois expressions.) Le
ce qui suit est le code équivalent pour l'instruction for :
expression1 ;
tandis que (expression2) {
déclaration;
expression3 ;
}

pause Cette instruction provoque une sortie forcée de l'instruction while englobante la plus récente ou
pour déclaration.

continuer
L'instruction continue (une extension) provoque l'encadrement le plus récent pour
instruction pour démarrer l'itération suivante.

arrêt L'instruction halt (une extension) est une instruction exécutée qui provoque le bc
processeur à quitter uniquement lorsqu'il est exécuté. Par exemple, "si (0 == 1) s'arrêter"
ne pas causer bc se terminer car l'arrêt n'est pas exécuté.

retourner Renvoie la valeur 0 à partir d'une fonction. (Voir la section sur les fonctions.)

retourner ( expression )
Renvoie la valeur de l'expression à partir d'une fonction. (Voir la section sur
fonctions.) En tant qu'extension, les parenthèses ne sont pas nécessaires.

PSEUDO ÉTATS
Ces déclarations ne sont pas des déclarations au sens traditionnel du terme. ils ne sont pas exécutés
déclarations. Leur fonction est exécutée au moment de la "compilation".

limites Imprimer les limites locales imposées par la version locale de bc. Ceci est une extension.

quitter Lorsque l'instruction quit est lue, le bc processeur est résilié, indépendamment de
où se trouve l'instruction quit. Par exemple, "si (0 == 1) quitter" provoquera bc
Terminer.

garantie
Imprimez un avis de garantie plus long. Ceci est une extension.

FONCTIONS
Les fonctions fournissent une méthode pour définir un calcul qui peut être exécuté ultérieurement.
Fonctions dans bc calcule toujours une valeur et la renvoie à l'appelant. Définitions de fonction
sont "dynamiques" dans le sens où une fonction est indéfinie jusqu'à ce qu'une définition soit rencontrée
dans l'entrée. Cette définition est ensuite utilisée jusqu'à ce qu'une autre fonction de définition pour le même
nom est rencontré. La nouvelle définition remplace alors l'ancienne définition. Une fonction
est défini comme suit:
Vous permet de définir prénom ( paramètres ) { nouvelle ligne
liste_auto liste_déclaration }
Un appel de fonction n'est qu'une expression de la forme "prénom(paramètres)".

Les paramètres sont des nombres ou des tableaux (une extension). Dans la définition de la fonction, zéro ou plus
les paramètres sont définis en listant leurs noms séparés par des virgules. Tous les paramètres sont
appel par paramètres de valeur. Les tableaux sont spécifiés dans la définition des paramètres par le
notation "prénom[]". Dans l'appel de fonction, les paramètres réels sont des expressions complètes pour
paramètres de nombre. La même notation est utilisée pour passer des tableaux que pour définir un tableau
paramètres. Le tableau nommé est passé par valeur à la fonction. Depuis la fonction
les définitions sont dynamiques, les numéros et les types de paramètres sont vérifiés lorsqu'une fonction est
appelé. Toute incompatibilité dans le nombre ou les types de paramètres entraînera une erreur d'exécution. UNE
une erreur d'exécution se produira également pour l'appel à une fonction non définie.

Votre liste_auto est une liste facultative de variables destinées à une utilisation « locale ». La syntaxe de
la liste automatique (si présente) est "auto prénom, ... ;". (Le point-virgule est facultatif.) Chaque prénom
est le nom d'une variable automatique. Les tableaux peuvent être spécifiés en utilisant la même notation que
utilisé dans les paramètres. Ces variables ont leurs valeurs poussées sur une pile au début de
la fonction. Les variables sont ensuite initialisées à zéro et utilisées tout au long de la
exécution de la fonction. À la sortie de la fonction, ces variables sont sautées de sorte que le
la valeur d'origine (au moment de l'appel de la fonction) de ces variables est restituée. Les
les paramètres sont vraiment des variables automatiques qui sont initialisées à une valeur fournie dans le
appel de fonction. Les variables automatiques sont différentes des variables locales traditionnelles car si
la fonction A appelle la fonction B, B peut accéder aux variables automatiques de la fonction A en utilisant simplement le
même nom, sauf si la fonction B les a appelés variables automatiques. En raison du fait que l'automobile
les variables et les paramètres sont poussés sur une pile, bc prend en charge les fonctions récursives.

Le corps de la fonction est une liste de bc déclarations. Encore une fois, les déclarations sont séparées par
des points-virgules ou des sauts de ligne. Les instructions de retour provoquent l'arrêt d'une fonction et le
retour d'une valeur. Il existe deux versions de l'instruction return. La première forme,
"retourner", renvoie la valeur 0 à l'expression appelante. La deuxième forme, "retourner (
expression )", calcule la valeur de l'expression et renvoie cette valeur à l'appelant
expression. Il y a un implicite "retourner (0)" à la fin de chaque fonction. Cela permet une
fonction pour terminer et retourner 0 sans instruction de retour explicite.

Les fonctions modifient également l'utilisation de la variable ibase. Toutes les constantes du corps de la fonction
sera converti en utilisant la valeur de ibase au moment de l'appel de la fonction. Changements de
ibase sera ignoré lors de l'exécution de la fonction sauf pour le standard
fonction lire, qui utilisera toujours la valeur actuelle de ibase pour la conversion des nombres.

Plusieurs extensions ont été ajoutées aux fonctions. Premièrement, le format de la définition a
été légèrement détendu. La norme exige que l'entretoise d'ouverture soit sur la même ligne que le
Vous permet de définir mot-clé et toutes les autres parties doivent être sur les lignes suivantes. Cette version de bc sera
autoriser un nombre quelconque de sauts de ligne avant et après l'accolade ouvrante de la fonction. Pour
exemple, les définitions suivantes sont légales.
définir d (n) { retourner (2*n); }
définir d (n)
{ retour (2*n); }

Les fonctions peuvent être définies comme annuler. Une fonction void ne renvoie aucune valeur et peut donc ne pas être
utilisé dans n'importe quel endroit qui a besoin d'une valeur. Une fonction void ne produit aucune sortie lorsque
appelé par lui-même sur une ligne d'entrée. Le mot clé annuler est placé entre le mot clé
Vous permet de définir et le nom de la fonction. Par exemple, considérons la session suivante.
define py (y) { print "--->", y, "<---", "\n" ; }
define void px (x) { print "--->", x, "<---", "\n" ; }
py(1)
--->1<---
0
px(1)
--->1<---
Depuis que py n'est pas une fonction vide, l'appel de py(1) imprime la sortie souhaitée, puis
imprime une deuxième ligne qui est la valeur de la fonction. Puisque la valeur d'une fonction
qui ne reçoit pas d'instruction de retour explicite est zéro, le zéro est affiché. Pour px(1),
aucun zéro n'est imprimé car la fonction est une fonction vide.

En outre, l'appel par variable pour les tableaux a été ajouté. Pour déclarer un appel par tableau de variables, le
la déclaration du paramètre du tableau dans la définition de la fonction ressemble à "*Nom[]". Le
l'appel à la fonction reste le même que l'appel par les tableaux de valeurs.

MATH BIBLIOTHÈQUE
If bc est invoqué avec le -l option, une bibliothèque mathématique est préchargée et l'échelle par défaut est
réglé sur 20. Les fonctions mathématiques calculeront leurs résultats à l'échelle définie au moment
de leur appel. La bibliothèque mathématique définit les fonctions suivantes :

s (x) Le sinus de x, x est en radians.

c (x) Le cosinus de x, x est en radians.

une (x) L'arc tangente de x, l'arc tangente renvoie des radians.

l (x) Le logarithme népérien de x.

etx) La fonction exponentielle d'élever e à la valeur x.

je (n, x)
La fonction de Bessel d'ordre entier n de x.

EXEMPLES
In / Bin / sh, ce qui suit affectera la valeur de "pi" à la variable shell pi.
pi=$(écho "échelle=10; 4*a(1)" | bc -l)

Ce qui suit est la définition de la fonction exponentielle utilisée dans la bibliothèque mathématique.
Cette fonction est écrite en POSIX bc.
échelle = 20

/* Utilise le fait que e^x = (e^(x/2))^2
Lorsque x est suffisamment petit, on utilise la série :
e^x = 1 + x + x^2/2 ! + x^3/3 ! + ...
*/

définir e(x) {
automatique a, ré, e, f, je, m, v, z

/* Vérifier le signe de x. */
si (x<0) {
m = 1
x = -x
}

/* Précondition x. */
z = échelle ;
échelle = 4 + z + 44*x ;
tandis que (x > 1) {
f + = 1 ;
x/= 2 ;
}

/* Initialise les variables. */
v = 1+x
un = x
d = 1

pour (i=2; 1; i++) {
e = (une *= x) / (d *= je)
si (e == 0) {
si (f>0) tandis que (f--) v = v*v;
échelle = z
si (m) retour (1/v) ;
retour (v/1);
}
v + = e
}
}

Le code suivant utilise les fonctionnalités étendues de bc mettre en œuvre un programme simple
pour le calcul des soldes de chéquiers. Ce programme est mieux conservé dans un fichier afin qu'il puisse être
utilisé plusieurs fois sans avoir à le retaper à chaque utilisation.
échelle=2
print "\nProgramme de carnet de chèques !\n"
print " N'oubliez pas que les dépôts sont des transactions négatives.\n"
print " Sortie par une transaction 0.\n\n"

imprimer « Solde initial ? » ; bal = lire()
balance /= 1
imprimer "\n"
tandis que (1) {
"solde actuel = " ; bal
« opération ? » ; trans = lire()
si (trans == 0) pause ;
bal -= trans
balance /= 1
}
quitter

Ce qui suit est la définition de la fonction factorielle récursive.
définir f (x) {
si (x <= 1) retourne (1) ;
retourner (f(x-1) * x);
}

LIRE LA LIGNE ET LIBÉDIT OPTIONS
GNU bc peut être compilé (via une option de configuration) pour utiliser le GNU readline éditeur d'entrée
bibliothèque ou le BSD libédite une bibliothèque. Cela permet à l'utilisateur d'éditer des lignes avant
les envoyer à bc. Il permet également un historique des lignes précédentes tapées. Quand ce
l'option est sélectionnée, bc a une autre variable spéciale. Cette variable spéciale, Histoire is
le nombre de lignes d'historique conservées. Pour readline, une valeur de -1 signifie qu'un
un nombre illimité de lignes d'historique est conservé. Réglage de la valeur de Histoire à
nombre positif limite le nombre de lignes d'historique au nombre donné. La valeur de 0
désactive la fonction d'historique. La valeur par défaut est 100. Pour plus d'informations, lisez le
manuels d'utilisation pour le GNU readline, Histoire et BSD libédite bibliothèques. On ne peut pas activer
tous les deux readline et libédite en même temps.

DIFFÉRENCES
Cette version de bc a été implémenté à partir du projet POSIX P1003.2/D11 et contient plusieurs
différences et extensions par rapport à l'ébauche et aux implémentations traditionnelles. Il est
pas mis en œuvre de manière traditionnelle en utilisant dc (1). Cette version est un processus unique
qui analyse et exécute une traduction de code d'octet du programme. Il y a un "sans papiers"
option (-c) qui oblige le programme à afficher le code d'octet sur la sortie standard à la place
de l'exécuter. Il a été principalement utilisé pour déboguer l'analyseur et préparer les mathématiques
bibliothèque.

Une source majeure de différences sont les extensions, où une fonctionnalité est étendue pour ajouter plus
fonctionnalités et ajouts, où de nouvelles fonctionnalités sont ajoutées. Voici la liste des
différences et extensions.

Environnement LANG
Cette version n'est pas conforme au standard POSIX dans le traitement du LANG
variable d'environnement et toutes les variables d'environnement commençant par LC_.

noms Traditionnel et POSIX bc avoir des noms à une lettre pour les fonctions, les variables et
tableaux. Ils ont été étendus pour être des noms à plusieurs caractères commençant par un
lettre et peut contenir des lettres, des chiffres et le caractère de soulignement.

String
Les chaînes ne sont pas autorisées à contenir des caractères NUL. POSIX dit que tous les caractères doivent
être inclus dans les chaînes.

dernier POSIX bc n'a pas de dernier variable. Quelques implémentations de bc utiliser la période
(.) d'une manière similaire.

comparaisons
POSIX bc autorise les comparaisons uniquement dans l'instruction if, l'instruction while et l'instruction
deuxième expression de l'instruction for. De plus, une seule opération relationnelle est
autorisé dans chacune de ces déclarations.

instruction if, clause else
POSIX bc n'a pas de clause else.

pour déclaration
POSIX bc requiert que toutes les expressions soient présentes dans l'instruction for.

&&, ||, !
POSIX bc n'a pas les opérateurs logiques.

fonction de lecture
POSIX bc n'a pas de fonction de lecture.

déclaration d'impression
POSIX bc n'a pas d'instruction d'impression.

continue déclaration
POSIX bc n'a pas d'instruction continue.

déclaration de retour
POSIX bc nécessite des parenthèses autour de l'expression de retour.

paramètres de tableau
POSIX bc ne prend pas (actuellement) en charge les paramètres de tableau dans leur intégralité. La grammaire POSIX
autorise les tableaux dans les définitions de fonctions, mais ne fournit pas de méthode pour spécifier
un tableau en tant que paramètre réel. (Il s'agit très probablement d'un oubli dans le
grammaire.) Implémentations traditionnelles de bc n'avoir qu'un appel par tableau de valeurs
paramètres.

format de fonction
POSIX bc nécessite l'accolade d'ouverture sur la même ligne que le Vous permet de définir mot clé et le
auto déclaration sur la ligne suivante.

=+, =-, =*, =/, =%, =^
POSIX bc ne nécessite pas la définition de ces opérateurs d'affectation "à l'ancienne".
Cette version peut autoriser ces affectations "à l'ancienne". Utilisez la déclaration de limites pour
voir si la version installée les prend en charge. S'il prend en charge "l'ancien style"
opérateurs d'affectation, l'instruction "a =- 1" décrémentera a par 1 au lieu de
mise a à la valeur -1.

espaces en nombre
D'autres implémentations de bc autoriser des espaces dans les nombres. Par exemple, "x=1 3"
affecter la valeur 13 à la variable x. La même instruction provoquerait une syntaxe
erreur dans cette version de bc.

erreurs et exécution
Cette implémentation diffère des autres implémentations en termes de code qui sera
exécuté lorsque la syntaxe et d'autres erreurs sont trouvées dans le programme. Si une erreur de syntaxe
se trouve dans une définition de fonction, la récupération d'erreur essaie de trouver le début d'un
instruction et continuer à analyser la fonction. Une fois qu'une erreur de syntaxe est trouvée dans le
fonction, la fonction ne sera pas appelable et devient indéfinie. Erreurs de syntaxe
dans le code d'exécution interactif invalidera le bloc d'exécution en cours. Les
bloc d'exécution se termine par une fin de ligne qui apparaît après un
séquence d'énoncés. Par exemple,
a = 1
b = 2
a deux blocs d'exécution et
{ un = 1
b = 2 }
a un bloc d'exécution. Toute erreur d'exécution mettra fin à l'exécution de la
bloc d'exécution. Un avertissement d'exécution ne terminera pas le bloc d'exécution en cours.

interruptions
Au cours d'une session interactive, le signal SIGINT (généralement généré par le contrôleur
caractère C du terminal) entraînera l'exécution du bloc d'exécution en cours
être interrompu. Il affichera une erreur "d'exécution" indiquant quelle fonction a été
interrompu. Une fois toutes les structures d'exécution nettoyées, un message sera
imprimé pour informer l'utilisateur que bc est prêt pour plus d'entrées. Tout défini précédemment
les fonctions restent définies et la valeur de toutes les variables non automatiques est la valeur à
le point d'interruption. Toutes les variables automatiques et paramètres de fonction sont supprimés
pendant le processus de nettoyage. Lors d'une session non interactive, le signal SIGINT
mettra fin à toute la course de bc.

LIMITES
Voici les limites actuellement en place pour ce bc processeur. Certains d'entre eux peuvent
ont été modifiés par une installation. Utilisez la déclaration des limites 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 de 16.

BC_DIM_MAX
Il s'agit actuellement d'une limite arbitraire de 65535 telle que distribuée. Votre installation
peut être différent.

BC_SCALE_MAX
Le nombre de chiffres après la virgule est limité à INT_MAX chiffres. Aussi,
le nombre de chiffres avant la virgule est limité à INT_MAX chiffres.

BC_STRING_MAX
La limite du nombre de caractères dans une chaîne est INT_MAX caractères.

exposant
La valeur de l'exposant dans l'opération d'élévation (^) est limitée à LONG_MAX.

noms de variables
La limite actuelle du nombre de noms uniques est de 32767 pour chacun des noms simples.
variables, tableaux et fonctions.

ENVIRONNEMENT VARIABLES

Les variables d'environnement suivantes sont traitées par bc:

POSIXLY_CORRECT
C'est le même que le -s option.

BC_ENV_ARGS
C'est un autre mécanisme pour obtenir des arguments bc. Le format est le même que le
arguments de ligne de commande. Ces arguments sont traités en premier, donc tous les fichiers répertoriés
dans l'environnement, les arguments sont traités avant tout fichier d'arguments de ligne de commande.
Cela permet à l'utilisateur de configurer des options et des fichiers « standards » à traiter à
chaque invocation de bc. Les fichiers dans les variables d'environnement seraient généralement
contenir des définitions de fonctions pour les fonctions que l'utilisateur souhaite définir à chaque fois bc is
fonctionner.

BC_LINE_LENGTH
Il doit s'agir d'un nombre entier spécifiant le nombre de caractères dans une ligne de sortie pour
Nombres. Cela inclut la barre oblique inverse et les caractères de nouvelle ligne pour les nombres longs. Comme
une extension, la valeur zéro désactive la fonction multiligne. Toute autre valeur
de cette variable qui est inférieure à 3 définit la longueur de ligne à 70.

DIAGNOSTIC

Si un fichier sur la ligne de commande ne peut pas être ouvert, bc signalera que le fichier est
indisponible et résilié. En outre, il existe des diagnostics de compilation et d'exécution qui devraient
être explicite.

Utilisez bc en ligne en utilisant les services onworks.net