Archive

BC- (1) Page manuelle

BC- (1) Page manuelle

Nom

BC - un langage de calculatrice de précision arbitraire

Syntaxe

avant JC [ -hlwsqv ] [options longues] [ déposer… ]]

Version

Cette page homme documente GNU BC version 1.06.

Description

avant JC est une langue qui prend en charge les numéros de précision arbitraires avec une exécution interactive des déclarations. Il existe des similitudes dans la syntaxe avec le langage de programmation C. Une bibliothèque mathématique standard est disponible par option de ligne de commande. Si demandé, la bibliothèque mathématique est définie avant de traiter les fichiers. avant JC Commence par traitement du code à partir de tous les fichiers répertoriés sur la ligne de commande dans la commande indiquée. Une fois que tous les fichiers ont été traités, avant JC Lit à partir de l'entrée standard. Tout le code est exécuté tel qu'il est lu. (Si un fichier contient une commande pour arrêter le processeur, avant JC ne lira jamais à partir de l'entrée standard.)

Cette version de avant JC contient plusieurs extensions au-delà avant JC les implémentations et la norme de projet POSIX. Les options de ligne de commande peuvent entraîner l'impression de ces extensions ou être rejetées. Ce document décrit la langue acceptée par ce processeur. Les extensions seront identifiées comme telles.

Options

-H, -Help
Imprimez l'utilisation et la sortie.
-I, -interactive
Forcer le mode interactif.
-L, -mathlib
Définissez la bibliothèque mathématique standard.
-w, -warn
Donnez des avertissements pour les extensions à POSIX avant JC.
-S,-standard
Traiter exactement le POSIX avant JC langue.
-Q, -quiet
N'imprimez pas le GNU Normal BC bienvenue.
-V, -Vursion
Imprimez le numéro de version et le droit d'auteur et quittez.

Nombres

L'élément le plus élémentaire dans avant JC est le nombre. Les nombres sont des numéros de précision arbitraires. Cette précision est à la fois dans la partie entière et dans la partie fractionnaire. Tous les nombres sont représentés en interne en décimal et tout le calcul est effectué en décimal. (Cette version tronque les résultats des opérations de division et de multiplication.) Il y a deux attributs de nombres, la longueur et l'échelle. La longueur est le nombre total de chiffres décimaux significatifs dans 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, des variables simples et des tableaux. Les variables simples et les variables de tableau sont nommées. Les noms commencent par une lettre suivie d'un certain nombre de lettres, chiffres et soulignements. Toutes les lettres doivent être minuscules. (Les noms alpha-numes complets sont une extension. Dans Posix avant JC Tous les noms sont une seule lettre en minuscules.) Le type de variable est clair par le contexte car tous les noms de variables de tableau seront suivis par des supports ([]).

Il existe quatre variables spéciales, échelle, ibase, obase, et dernier. escalader Définit comment certaines opérations utilisent des chiffres après le point décimal. La valeur par défaut de escalader est 0. ibase et obase Définissez la base de conversion pour les nombres d'entrée et de sortie. La valeur par défaut pour l'entrée et la sortie est la base 10. dernier (une extension) est une variable qui a la valeur du dernier numéro imprimé. Ceux-ci seront discutés plus en détail le cas échéant. Toutes ces variables peuvent avoir des valeurs qui leur sont attribuées ainsi que utilisées dans les expressions.

commentaires

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

Pour soutenir l'utilisation des scripts pour avant JC, Un commentaire à ligne unique a été ajouté comme extension. Un commentaire à ligne unique commence à un # caractère et continue à l'extrémité 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 a été conçue pour être interactive, 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é tel qu'il est rencontré. (Les fonctions, discutées en détail plus tard, sont définies lorsqu'ils sont rencontrés.)

Une expression simple est juste une constante. avant JC convertit les constantes en nombres décimaux internes à l'aide de la base d'entrée actuelle, spécifiée par la variable ibase. (Il y a une exception dans les fonctions.) Les valeurs juridiques de ibase sont 2 à 16. Attribuer une valeur en dehors de cette plage à ibase entraînera une valeur de 2 ou 16. Les numéros d'entrée peuvent contenir les caractères 0-9 et A-F. (Remarque: ils doivent être des capitales. Les lettres en minuscules sont des noms de variables.) Les nombres à un chiffre ont toujours la valeur du chiffre quelle que soit la valeur de ibase. (je.e. A = 10.) Pour les numéros à plusieurs chiffres, avant JC modifie tous les chiffres d'entrée supérieurs ou égaux à iBase à la valeur de ibase-1. Cela fait le numéro FFF Soyez toujours le plus grand numéro à 3 chiffres de la base d'entrée.

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

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 une variable. Une variable simple n'est qu'un

nom

et une variable de tableau est spécifiée comme

nom[expr]]

Sauf mentionné spécifiquement, l'échelle du résultat est l'échelle maximale des expressions impliquées.

- expr
Le résultat est la négation de l'expression.
++ var
La variable est incrémentée d'un et la nouvelle valeur est le résultat de l'expression.
- var
La variable est décrémentée de une seule et la nouvelle valeur est le résultat de l'expression.
var ++
Le résultat de l'expression est la valeur de
la variable puis la variable est incrémentée d'un.
var -
Le résultat de l'expression est la valeur de la variable puis la variable est décrémentée de.
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 escalader.
expr% expr
Le résultat de l'expression est le «reste» et il est calculé de la manière suivante. Pour calculer un% B, d'abord A / B est calculé pour escalader chiffres. Ce résultat est utilisé pour calculer A- (A / B) * B à l'échelle du maximum de escalader+échelle (b) et échelle (a). Si escalader est défini sur zéro et les deux expressions sont entiers Cette expression est la fonction reste entière.
expr ^ expr
Le résultat de l'expression est la valeur du premier élevé au second. 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 escalader Si l'exposant est négatif. Si l'exposant est positif escalader et l'échelle de la première expression. (e.g. échelle (a ^ b) = min (échelle (a) * b, max ( escalader, échelle (a))).) Il convient de noter que l'expr ^ 0 renverra toujours la valeur de 1.
(expr)
Cela modifie la priorité standard pour forcer l'évaluation de l'expression.
var = expr
La variable se voit attribuer la valeur de l'expression.
var = expr
Cela équivaut à «var = var expr» à l'exception 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 type d'expression spécial 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 quelle expression juridique. (POSIX BC exige que les expressions relationnelles soient utilisées uniquement dans si, pendant que et pour les déclarations et qu'un seul test relationnel peut être effectué en eux.) Les opérateurs relationnels sont

expr1 < expr2
Le résultat est 1 si l'expr1 est strictement inférieur à l'expr2.
expr1 <= expr2
Le résultat est 1 si l'expr1 est inférieur ou égal à expr2.
expr1> expr2
Le résultat est 1 si l'expr1 est strictement supérieur à l'expr2.
expr1> = expr2
Le résultat est 1 si l'expr1 est supérieur ou égal à expr2.
expr1 == expr2
Le résultat est 1 si l'expr1 est égal à expr2.
expr1 != expr2
Le résultat est 1 si l'expr1 n'est pas égal à expr2.

Les opérations booléennes sont également légales. (POSIX avant JC n'a pas d'opérations booléennes). Le résultat de toutes les opérations booléennes est 0 et 1 (pour les fausses et vraies) comme dans les expressions relationnelles. Les opérateurs booléens sont:

!expr
Le résultat est 1 si l'expr est 0.
expr && expr
Le résultat est 1 si les deux expressions sont non nulles.
expr || expr
Le résultat est 1 si l'une ou l'autre expression est non nulle.

La priorité d'expression est la suivante: (le plus bas au plus élevé)

|| Opérateur, gauche associative et opérateur, gauche associative ! opérateur, non associé
Opérateurs relationnels,
Opérateur d'attribution associatif gauche, opérateurs associatifs droits + et -,
Associatif gauche *, / et% opérateurs, opérateur associatif gauche ^, Associatif droit
UNARY - OPÉRATEUR, NON ASSOCIATIVE ++ et - Opérateurs, non associatif

Cette priorité a été choisie de sorte que Posix est conforme avant JC Les programmes fonctionneront correctement. Cela entraînera l'utilisation des opérateurs relationnels et logiques pour avoir un comportement inhabituel lorsqu'il est utilisé avec des expressions d'affectation. Considérez l'expression:

a = 3 < 5

La plupart des programmeurs C supposeraient que cela attribuerait le résultat de «3 < 5” (the value 1) to the variable “a”. What this does in avant JC est attribué la valeur 3 à la variable «A» puis compare 3 à 5. Il est préférable d'utiliser des parenthèses lors de l'utilisation des opérateurs relationnels et logiques avec les opérateurs d'affectation.

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

longueur (expression)
La valeur de la fonction de longueur est le nombre de chiffres significatifs dans l'expression.
lire ( )
La fonction de lecture (une extension) lira un nombre à partir de l'entrée standard, peu importe où la fonction se produit. Méfiez-vous, cela peut causer des problèmes avec le mélange des données et du programme dans l'entrée standard. La meilleure utilisation pour cette fonction est dans un programme précédemment écrit qui a besoin de contribution de l'utilisateur, mais ne permet jamais de saisir le code du programme de l'utilisateur. La valeur de la fonction de lecture est le nombre de lecture à partir de l'entrée standard en utilisant 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 le point décimal de 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.

Affirmations

Les déclarations (comme dans la plupart des langues algébriques) fournissent le séquençage de l'évaluation de l'expression. Dans avant JC Les déclarations sont exécutées «dès que possible.»L'exécution se produit lorsqu'une nouvelle ligne a rencontré et qu'il y a une ou plusieurs instructions complètes. En raison de cette exécution immédiate, les nouvelles lignes sont très importantes avant JC. En fait, un point-virgule et une nouvelle ligne sont utilisés comme séparateurs de déclaration. Une nouvelle ligne mal placée entraînera une erreur de syntaxe. Parce que NewLines sont des séparateurs de déclaration, il est possible de masquer une nouvelle ligne en utilisant le caractère bombardement. La séquence «\», où la nouvelle ligne semble avant JC En tant qu'espace blanc au lieu d'une nouvelle ligne. Une liste de déclarations est une série de déclarations séparées par des demi-colons et des nouvelles lignes. Ce qui suit est une liste de avant JC Les déclarations et ce qu'ils font: (les choses enfermées entre parenthèses ([]) 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 de cession. Si l'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 déclaration de cession et «(a = 1)» est une expression qui a une affectation intégrée. Tous les numéros imprimés sont imprimés dans la base spécifiée par la variable obase. Les valeurs juridiques pour obase sont 2 à BC_Base_max. (Voir les limites de la section.) Pour les bases 2 à 16, la méthode habituelle d'écriture est utilisée. Pour les bases supérieures à 16, avant JC Utilise une méthode de chiffre à plusieurs caractères pour imprimer les nombres où chaque chiffre de base supérieur est imprimé comme un numéro de base 10. Les chiffres à plusieurs caractères sont séparés par des espaces. Chaque chiffre contient le nombre de caractères nécessaires pour représenter la valeur de base de la base de "Obase-1". Étant donné que les nombres sont de précision arbitraire, certains nombres peuvent ne pas être imprimables sur une seule ligne de sortie. Ces longs nombres seront divisés entre 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. En raison de la nature interactive de avant JC, L'impression d'un nombre provoque l'effet secondaire de l'attribution de 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 qui a imprimé le numéro. Attribution à dernier est légal et écrasera la dernière valeur imprimée avec la valeur attribuée. La valeur nouvellement attribuée restera jusqu'à l'imprimé le numéro suivant 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 notation de la main courte pour dernier.)
chaîne
La chaîne est imprimée à la sortie. Les cordes commencent par un caractère à double devis et contiennent tous les caractères jusqu'à ce que le personnage à double devis suivant. Tous les personnages prennent littéralement, y compris toute nouvelle ligne. Aucun caractère Newline n'est imprimé après la chaîne.
imprimer liste
L'instruction d'impression (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 newline terminale n'est imprimée. Les expressions sont évaluées et leur valeur est imprimée et affectée à la variable dernier. Les cordes de l'instruction PRINT sont imprimées à la sortie et peuvent contenir des caractères spéciaux. Les caractères spéciaux commencent par le caractère de barre arrière (\). Les caractères spéciaux reconnus par avant JC sont «a» (alerte ou cloche), «b» (backspace), «f» (Form Feed), «n» (newline), «r» (retour chariot), «Q» (double citation), «t »(Tab) et« \ »(arrière). Tout autre personnage qui suit l'arrière-plan sera ignoré.
instruction_list
Ceci est la déclaration composée. Il permet de regrouper plusieurs instructions pour exécuter.
si (expression) instruction1 [autre instruction2]
L'instruction if évalue l'expression et exécute la déclaration 1 ou la déclaration2 en fonction de la valeur de l'expression. Si l'expression n'est pas nulle, Statement1 est exécuté. Si l'instruction2 est présente et que la valeur de l'expression est 0, alors la déclaration2 est exécutée. (La clause ELSE est une extension.)
alors que (expression)
L'instruction while exécutera l'instruction tandis que l'expression n'est pas nulle. Il évalue l'expression avant chaque exécution de l'instruction. La terminaison de la boucle est causée par une valeur d'expression nulle ou l'exécution d'une déclaration de rupture.
pour ([expression1]; [expression2]; [expression3])
Les contrôles de déclaration pour l'exécution répétée de l'instruction. Expression1 est évalué avant la boucle. Expression2 est évalué avant chaque exécution de l'instruction. S'il n'est pas nul, l'instruction est évaluée. S'il est nul, la boucle est terminée. Après chaque exécution de l'instruction, l'expression3 est évaluée avant la réévaluation de l'expression2. Si l'expression1 ou l'expression3 sont manquantes, rien n'est évalué au point qu'ils seraient évalués. Si l'expression2 est manquante, c'est la même chose que de substituer la valeur 1 à l'expression2. (Les expressions facultatives sont une extension. Posix avant JC nécessite les trois expressions.) Les éléments suivants sont un code équivalent pour l'instruction FOR: 
expression1; while (expression2) instruction; expression3;
casser
Cette déclaration provoque une sortie forcée de la déclaration la plus récente de la déclaration ou de la déclaration.
continuer
L'énoncé de poursuite (une extension) provoque la clôture la plus récente pour démarrer la prochaine itération.
arrêt
L'instruction HALT (une extension) est une déclaration exécutée qui provoque le avant JC processeur à quitter uniquement lorsqu'il est exécuté. Par exemple, «if (0 == 1) Halt» ne provoquera pas avant JC Pour se terminer parce que l'arrêt n'est pas exécuté.
retour
Renvoyer la valeur 0 à partir d'une fonction. (Voir la section sur les fonctions.)
retour ( expression )
Renvoie la valeur de l'expression d'une fonction. (Voir la section sur les fonctions.) En tant qu'extension, les parenthèses ne sont pas nécessaires.

Pseudo

Ces déclarations ne sont pas des déclarations au sens traditionnel. Ce ne sont pas des déclarations exécutées. Leur fonction est effectuée à l'heure «compiler».

limites
Imprimer les limites locales appliquées par la version locale de avant JC. Ceci est une extension.
arrêter
Lorsque l'instruction QUIT est lue, le avant JC Le processeur est terminé, quel que soit le lieu de découverte de la déclaration. Par exemple, «if (0 == 1) quitter» provoquera avant JC Terminer.
garantie
Imprimer un avis de garantie plus long. Ceci est une extension.

Les fonctions

Les fonctions fournissent une méthode pour définir un calcul qui peut être exécuté ultérieurement. Fonctionne dans avant JC Calculez toujours une valeur et renvoyez-la à l'appelant. Les définitions de fonction sont «dynamiques» dans le sens où une fonction n'est pas dé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 du même nom soit rencontrée. La nouvelle définition remplace ensuite l'ancienne définition. Une fonction est définie comme suit:

définir le nom (paramètres) newline Auto_List Statement_List

Un appel de fonction n'est qu'une expression de la forme "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 de paramètres sont définis en répertoriant leurs noms séparés par des virgules. Tous les paramètres sont des paramètres d'appel 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 du nombre. La même notation est utilisée pour passer des tableaux comme pour définir les paramètres du tableau. Le tableau nommé est transmis par valeur à la fonction. Étant donné que les définitions de fonction sont dynamiques, les nombres de paramètres et les types sont vérifiés lorsqu'une fonction est appelée. Tout décalage dans le nombre ou les types de paramètres entraînera une erreur d'exécution. Une erreur d'exécution se produira également pour l'appel à une fonction non définie.

Le Auto_List est une liste facultative des variables pour une utilisation «locale». La syntaxe de la liste automatique (si elle est présente) est «auto nom,…; ». (Le point-virgule est 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 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 l'exécution de la fonction. À la sortie de la fonction, ces variables sont éclatées de sorte que la valeur d'origine (au moment de l'appel de fonction) de ces variables soit restaurée. Les paramètres sont vraiment des variables auto qui sont initialisées à une valeur fournie dans l'appel de fonction. Les variables automobiles sont différentes des variables locales traditionnelles car si la fonction a appelle la fonction B, B peut accéder aux variables auto de la fonction A en utilisant simplement le même nom, à moins que la fonction B ne les ait appelés variables automobiles. En raison du fait que les variables et paramètres automobiles sont poussés sur une pile, avant JC prend en charge les fonctions récursives.

Le corps de fonction est une liste de avant JC affirmations. Encore une fois, les déclarations sont séparées par des demi-colons ou des nouvelles lignes. Les déclarations de retour provoquent la résiliation d'une fonction et le retour d'une valeur. Il y a deux versions de l'énoncé de retour. La première forme, "retour«, Renvoie la valeur 0 à l'expression appelée. La deuxième forme, "retour ( expression )", Calcule la valeur de l'expression et renvoie cette valeur à l'expression appelée. Il y a un implicite "retour (0)"À la fin de chaque fonction. Cela permet à une fonction de se terminer et de retourner 0 sans instruction de retour explicite.

Les fonctions modifient également l'utilisation de la variable ibase. Toutes les constantes du corps de fonction seront converties en utilisant la valeur de ibase Au moment de l'appel de la fonction. Changements ibase sera ignoré lors de l'exécution de la fonction à l'exception de la fonction standard 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 nécessite que l'automne d'ouverture soit sur la même ligne définir mot-clé et toutes les autres pièces doivent être sur les lignes suivantes. Cette version de avant JC permettra un certain nombre de nouvelles lignes avant et après l'autoroute d'ouverture de la fonction. Par exemple, les définitions suivantes sont légales.

Cw définir d (n) return (2 * n);  définir d (n) return (2 * n);

Les fonctions peuvent être définies comme annuler. Une fintion vide ne renvoie aucune valeur et ne peut donc être utilisée dans n'importe quel endroit qui a besoin d'une valeur. Une fonction vide ne produit aucune sortie lorsqu'elle est appelée par elle-même sur une ligne d'entrée. Le mot clé annuler est placé entre le mot clé définir et le nom de la fonction. Par exemple, considérez la session suivante.

Cw définir py (y) print "--->", y, "<---", "0;  define void px (x)
print "--->", x, "11<---

Depuis 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. Étant donné que la valeur d'une fonction qui ne reçoit pas une instruction de retour explicite est nulle, le zéro est imprimé. Pour PX (1) , Aucun zéro n'est imprimé car la fonction est une fonction vide.

De plus, l'appel par variable pour les tableaux a été ajouté. Pour déclarer un appel par tableau variable, la déclaration du paramètre du tableau dans la définition de la fonction ressemble à «*nom[]". L'appel à la fonction reste le même que les tableaux d'appel par valeur.

Bibliothèque mathématique

Si avant JC est invoqué avec le -l Option, une bibliothèque mathématique est préchargée et l'échelle par défaut est définie 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.
un (X)
L'arctangent de x, Arctangent renvoie les radians.
l (X)
Le logarithme naturel de x.
e (X)
La fonction exponentielle de l'augmentation de la valeur x.
J (n, x)
La fonction Bessel de l'ordre entier n de x.

Exemples

In / bin / sh, ce qui suit attribuera la valeur de «Pi» à la variable de coquille pi.

Cw pi = $ (echo “échelle = 10; 4 * a (1)” | bc -l)

Voici la définition de la fonction exponentielle utilisée dans la bibliothèque mathématique. Cette fonction est écrite en POSIX avant JC.

Échelle CW = 20 / * utilise le fait que e ^ x = (e ^ (x / 2)) ^ 2
Lorsque X est assez petit, nous utilisons la série:
 e ^ x = 1 + x + x ^ 2/2! + x ^ 3/3! +… * / Définir e (x) auto a, d, e, f, i, m, v, z
/ * Vérifiez le signe de x. * / if (x<0)  m = 1 x = -x 
 / * Précondition x. * / z = échelle; échelle = 4 + z + .44 * x;
 while (x> 1) f + = 1; x / = 2; 
 / * Initialiser les variables. * / v = 1 + x a = x d = 1 pour (i = 2; 1; i ++)
 e = (a * = x) / (d * = i) if (e == 0) if (f> 0) while (f--)
v = v * v; échelle = z if (m) return (1 / v); retour (v / 1);  v + = e

Ce qui suit est un code qui utilise les fonctionnalités étendues de avant JC Pour implémenter un programme simple pour calculer les soldes de chéquier. Ce programme est mieux conservé dans un fichier afin qu'il puisse être utilisé plusieurs fois sans avoir à le retaper à chaque utilisation.

CW Scale = 2 Imprimer "\ nCheck Book Program!\ n "imprimer"
N'oubliez pas que les dépôts sont des transactions négatives.\ n "imprimer"
 Sortir par une transaction 0.\ n \ n "imprimer" Balance initiale? "; Bal = read () Bal / = 1
print "\ n" while (1) "Current Balance ="; Bal "Transaction? "; trans = read ()
if (trans == 0) casser; Bal - = trans Bal / = 1 quitte

Ce qui suit est la définition de la fonction factorielle récursive.

Cw définir f (x) if (x <= 1) return (1); return (f(x-1) * x);

Options de lecture et de libedit

GNOU avant JC peut être compilé (via une option de configuration) pour utiliser le GNU ligne de lecture Bibliothèque d'éditeur d'entrée ou BSD libedit bibliothèque. Cela permet à l'utilisateur de rédiger des lignes avant de les envoyer à avant JC. Il permet également un historique des lignes précédentes tapées. Lorsque cette option est sélectionnée, avant JC a une variable spéciale de plus. Cette variable spéciale, histoire Le nombre de lignes d'histoire est-elle conservée. Pour ligne de lecture, Une valeur de -1 signifie qu'un nombre illimité de lignes d'histoire sont conservés. Définition de la valeur de histoire à un nombre positif restreint le nombre de lignes d'histoire au nombre donné. La valeur de 0 désactive la fonction historique. La valeur par défaut est 100. Pour plus d'informations, lisez les manuels d'utilisation du GNU ligne de lecture, histoire et bsd libedit bibliothèques. On ne peut pas activer les deux ligne de lecture et libedit en même temps.

Différences

Cette version de avant JC a été implémenté à partir du POSIX P1003.2 / d11 rédiger et contient plusieurs différences et extensions par rapport au projet et aux implémentations traditionnelles. Il n'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 existe une option «sans papiers» (-C) qui fait sortir le code du programme à la sortie standard au lieu de l'exécuter. Il a été principalement utilisé pour déboguer l'analyseur et préparer la bibliothèque mathématique.

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

Environnement Lang
Cette version n'est pas conforme à la norme POSIX dans le traitement de la variable d'environnement Lang et de toutes les variables d'environnement à partir de LC_.
des noms
Traditionnel et POSIX avant JC ont des noms de lettres uniques pour les fonctions, les variables et les tableaux. Ils ont été étendus pour être des noms à plusieurs caractères qui commencent par une lettre et peuvent contenir des lettres, des chiffres et le caractère de soulignement.
Cordes
Les cordes ne sont pas autorisées à contenir des caractères Nul. POSIX dit que tous les personnages doivent être inclus dans les chaînes.
dernier
Posix avant JC n'a pas de dernier variable. Certaines implémentations de avant JC Utilisez la période (.) d'une manière similaire.
comparaisons
Posix avant JC Permet des comparaisons uniquement dans l'instruction if, l'instruction while et la deuxième expression de l'instruction FOR. De plus, une seule opération relationnelle est autorisée dans chacune de ces déclarations.
Si déclaration, clause else
Posix avant JC n'a pas de clause d'autre.
pour déclaration
Posix avant JC nécessite que toutes les expressions soient présentes dans la déclaration pour.
&&, ||, !
Posix avant JC n'a pas les opérateurs logiques.
fonction de lecture
Posix avant JC n'a pas de fonction de lecture.
déclaration d'impression
Posix avant JC n'a pas de déclaration d'impression .
Continuer la déclaration
Posix avant JC n'a pas de déclaration de poursuite.
déclaration de retour
Posix avant JC nécessite des parenthèses autour de l'expression de retour.
paramètres du tableau
Posix avant JC ne prend pas (actuellement) en charge les paramètres du tableau complet. La grammaire POSIX permet des tableaux dans les définitions de fonction, mais ne fournit pas de méthode pour spécifier un tableau en tant que paramètre réel. (C'est probablement une supervision de la grammaire.) Implémentations traditionnelles de avant JC n'ont que les paramètres d'appel par rapport de valeur.
format de fonction
Posix avant JC nécessite l'attelle d'ouverture sur la même ligne que le définir mot clé et le auto déclaration sur la ligne suivante.
= +, = -, = *, = /, =%, = ^
Posix avant JC ne nécessite pas que ces opérateurs d'affectation «à l'ancienne» soient définis. Cette version peut permettre à ces affectations «à l'ancienne». Utilisez l'instruction Limits pour voir si la version installée les prend en charge. S'il prend en charge les opérateurs d'affectation «à l'ancienne», l'instruction «a = - 1» diminuera un par 1 au lieu de régler un à la valeur -1.
Espaces en nombre
Autres implémentations de avant JC Autoriser les espaces en nombre. Par exemple, «x = 1 3» attribuerait la valeur 13 à la variable x. La même déclaration entraînerait une erreur de syntaxe dans cette version de avant JC.
erreurs et exécution
Cette implémentation varie des autres implémentations en termes de code qui sera exécuté lorsque la syntaxe et d'autres erreurs se trouvent dans le programme. Si une erreur de syntaxe se trouve dans une définition de fonction, l'erreur Recovery essaie de trouver le début d'une instruction et de continuer à analyser la fonction. Une fois qu'une erreur de syntaxe est trouvée dans la fonction, la fonction ne sera pas appelée et ne sera pas définie. Les erreurs de syntaxe dans le code d'exécution interactif invalideront le bloc d'exécution actuel. Le bloc d'exécution est terminé par une fin de ligne qui apparaît après une séquence complète des déclarations. Par exemple, 
a = 1 b = 2

a deux blocs d'exécution et

a = 1 b = 2

a un bloc d'exécution. Toute erreur d'exécution mettra fin à l'exécution du bloc d'exécution actuel. Un avertissement d'exécution ne terminera pas le bloc d'exécution actuel.

Interruptions
Au cours d'une session interactive, le signal SIGINT (généralement généré par le caractère Control-C à partir du terminal) entraînera l'interruption de l'exécution du bloc d'exécution actuel. Il affichera une erreur «d'exécution» indiquant quelle fonction a été interrompue. Une fois que toutes les structures d'exécution ont été nettoyées, un message sera imprimé pour informer l'utilisateur que avant JC est prêt pour plus d'entrée. Toutes les fonctions précédemment définies restent définies et la valeur de toutes les variables non auto est la valeur au point d'interruption. Toutes les variables auto et les paramètres de fonction sont supprimés pendant le processus de nettoyage. Au cours d'une session non interactive, le signal SIGINT mettra fin à toute la course de avant JC.

Limites

Voici les limites actuellement en place pour cela avant JC processeur. Certains d'entre eux peuvent avoir été modifiés par une installation. Utilisez l'instruction Limits pour voir les valeurs réelles.

BC_BASE_MAX
La base de sortie maximale est actuellement définie à 999. La base d'entrée maximale est 16.
BC_DIM_MAX
Il s'agit actuellement d'une limite arbitraire de 65535 comme distribué. Votre installation peut être différente.
BC_SCALE_MAX
Le nombre de chiffres après le point décimal est limité aux chiffres int_max. De plus, le nombre de chiffres avant le point décimal est limité aux chiffres int_max.
Bc_string_max
La limite du nombre de caractères dans une chaîne est des caractères int_max.
exposant
La valeur de l'exposant dans l'opération d'élévation (^) est limitée à long_max.
Noms variables
La limite actuelle du nombre de noms uniques est de 32767 pour chacune des variables, tableaux et fonctions simples.

Variables d'environnement

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

Posixly_correct
C'est la même chose que le -s option.
Bc_env_args
Ceci est un autre mécanisme pour obtenir des arguments avant JC. Le format est le même que les arguments de ligne de commande. Ces arguments sont d'abord traités, de sorte que tous les fichiers répertoriés dans les arguments de l'environnement sont traités avant tous. Cela permet à l'utilisateur de configurer des options et des fichiers «standard» à traiter à chaque invocation de avant JC. Les fichiers des variables d'environnement contiendraient généralement des définitions de fonction des fonctions que l'utilisateur veut définir à chaque fois avant JC est coulé.
Bc_line_length
Cela devrait ê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 arrière et de Newline pour de longs nombres. En tant qu'extension, la valeur de zéro désactive la fonction multi-ligne. Toute autre valeur de cette variable inférieure à 3 définit la longueur de ligne à 70.

Diagnostique

Si un fichier sur la ligne de commande ne peut pas être ouvert, avant JC signalera que le fichier n'est pas disponible et se termine. De plus, il existe des diagnostics de compilation et d'exécution qui devraient être explicites.

Insectes

La récupération des erreurs n'est pas encore très bonne.

Envoyer des rapports de bogue à bug-bc @ gnu.org. Assurez-vous d'inclure le mot "BC" quelque part dans le champ "Sujet:".

Auteur

Philip. Nelson Philnelson @ ACM.org

Remerciements

L'auteur tient à remercier Steve Sommars (Steve.Sommars @ att.com) pour sa grande aide pour tester la mise en œuvre. De nombreuses grandes suggestions ont été données. C'est un bien meilleur produit en raison de son implication.

Tutoriels Linux connexes:

  • Conseils de ligne de commande bash utiles et exemples de trucs - Partie 1
  • Masterring Bash Script Loops
  • Boucles imbriquées dans les scripts bash
  • Comment utiliser des sous-coquilles bash à l'intérieur des instructions IF
  • Bases de mathématiques informatiques: binaire, décimal, hexadécimal, octal
  • Commande man dans Linux avec des exemples
  • Comment créer des sauvegardes incrémentielles et différentielles avec du goudron
  • Bash si déclarations: si, elif, sinon, alors, fi
  • Scénarios de bash: conditionnels
  • Comment accéder aux pages manuelles pour les commandes Linux