\documentclass{report}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{textcomp}
\usepackage{geometry}
\geometry{top=15mm, bottom=15mm, left=1cm, right=1cm}
\usepackage[french]{babel}
\usepackage{pslatex}
\usepackage[colorlinks=true,urlcolor=black]{hyperref}
\usepackage{graphicx}
\usepackage{fancyhdr}
\pagestyle{fancy}
\renewcommand{\footrulewidth}{0.4pt}
\fancyfoot[L]{Uubu.fr}
\fancyfoot[R]{mer. mars 5 11:57:03 CET 2014}
\lfoot{\Large \textit{Uubu.fr}}
\hypersetup{pdfinfo={
Title={bc},
Author={Sylvain Girod},
Creator={Bash script from uubu.fr's format version 1},
Producer={Bash script and PDFLaTeX},
Subject={langage de calcul arbitraire},
CreationDate={D:20140305115703},
ModDate={D:20140305115703},
Keywords={GNU;scripts;programmation}
}}
\begin{document}
 
\begin{center}
{\Huge bc }
\end{center}
\vspace{1cm}
 
\begin{flushleft}
 
{\large langage de calcul arbitraire}
 
\vspace{10mm}
 
\hspace{1mm}  bc est un langage qui supporte les nombres à précision arbitraire avec exécution intéractive des déclarations. Il y'a certaines similarités avec le langage C. \textbf{bc} commence par traiter le code depuis tous les fichiers de la ligne de commande, puis il lit l'entrée standard.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge OPTIONS }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} -i, --interactive]{Mode interactif}
\item[\hspace{1mm} -l, --mathlib]{Définis la librairie standard}
\item[\hspace{1mm} -w, --warn]{Donne des alertes pour les extensions à bc POSIX}
\item[\hspace{1mm} -q, --quiet]{N'affiche pas le message de bienvenu}
\end{description}
 
\vspace{1cm}{\huge Nombres }
 
\
 
\hspace{1mm}  C'est l'élément de base de bc. Les nombres sont de précision arbitraire. Tous les nombres sont représentés en interne en décimal et tous les calculs sont fait en décimal. Il y'a 2 attributs de nombres. la longueur et l'échelle. La longueur est le nombre total de chiffres et l'échelle et le nombre total après le point décimal. Par ex:
\vspace{5mm} \\
\hspace{1mm}  .000001 a une longueur de 6 et une échelle de 6.
\vspace{5mm} \\
\hspace{1mm}  1935.000 a une longueur de 7 et une échelle de 3.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Variables }
 
\
 
\hspace{1mm}  Les nombres sont stockés dans 2 types de variables, les variables simples et le tableaux. Ces deux types sont nommés. Les noms commencent avec une lettre suivi par des lettres, chiffres et '\_'. Toutes les lettres doivent être en minuscules.
\vspace{5mm} \\
\hspace{1mm}  Il y'a 4 types spéciaux de variables, \textbf{scale}, \textbf{ibase}, \textbf{obase} et \textbf{base}. \textbf{scale} définis la manière dont certaines opérations utilisent les chiffres après le point décimal (défaut: 0). \textbf{ibase} et \textbf{obase} définissent le base de conversion pour les nombres entrant et sortant (défaut: 10). \textbf{last} est une variable qui a la valeur du dernier nombre affiché.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Commentaires }
 
\
 
\hspace{1mm}  Les commentaires dans bc commencent avec \textbf{/*} et se terminent par \textbf{*/}.
\vspace{5mm} \\
\hspace{1mm}  \textbf{\#} peut également être utilisé pour les commentaire sur une seule ligne.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Expressions }
 
\
 
\hspace{1mm}  Les nombres sont manipulés par des expressions et des déclarations. Il n'y a pas de programme main. À la place, le code est exécutés tel qu'il est rencontré.
\vspace{5mm} \\
\hspace{1mm}  Une simple expression est simplement une constante. bc convertis les constantes en nombres décimal en utilisant la base d'entrée courante, spécifiée par la variable ibase. Les valeurs légales de ibase vont de 2 à 16. Les nombres en entrée peuvent contenir les caractères 0-9 en A-F. Pour les nombres à plusieurs chiffres, bc change tous les chiffres supérieurs ou égal à la valeur de ibase-1. Cela fait du nombre FFF toujours plus large que 3 chiffre de la base d'entrée
\vspace{5mm} \\
 
 
\hspace{1mm}  Les expressions sont similaires à d'autre langages de haut niveau. Vu qu'il n'y a qu'un type de nombre, il n'y a pas de règles pour mixer les types. À la place, il y'a des règles sur l'échelle des expressions. Toute expression a une échelle. L'échelle est dérivée des nombres originaux, l'opération est effectuée dans tous les cas, la valeur de la variable scale. les valeurs légales de scale vont de 0 au nombre maximum représentable par un entier C.
\vspace{5mm} \\
\hspace{1mm}  Dans les descriptions suivantes d'expressions légales, expr réfère à une expression complète et var réfère à une variable simple ou un tableau.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} Une variable simple est juste:]{name}
\item[\hspace{1mm} et un tableau est spécifié:]{name[expr]}
\item[\hspace{1mm} ]{}
\item[\hspace{1mm} - expr]{Le résultat est la négation de l'expression}
\item[\hspace{1mm} ++ var]{La variable est incrémenté de un et la nouvelle valeur est le résultat de l'expression}
\item[\hspace{1mm} -- var]{La variable est décrémenté de un et la nouvelle valeur est le résultat de l'expression}
\item[\hspace{1mm} var ++]{Le résultat de l'expression est la valeur de la variable puis la variable est incrémenté}
\item[\hspace{1mm} var --]{Le résultat de l'expression est la valeur de la variable puis la variable est décrémenté}
\item[\hspace{1mm} expr + expr]{Le résultat de l'expression est la somme des 2 expressions}
\item[\hspace{1mm} expr - expr]{Le résultat de l'expression est la différence des 2 expressions}
\item[\hspace{1mm} expr * expr]{Le résultat de l'expression est le produit des 2 expressions}
\item[\hspace{1mm} expr / expr]{Le résultat de l'expression est de quotient des 2 expressions. l'échelle du résultat est la valeur de la variable scale}
\item[\hspace{1mm} expr \% expr]{Le résultat de l'expression est le reste}
\item[\hspace{1mm} expr \textasciicircum expr]{Le résultat de l'expression est la valeur de la première élevé à la seconde. La seconde expression doit être un entier.}
\item[\hspace{1mm} ( expr )]{Altère la précédence standard pour forcer l'évaluation de l'expression}
\item[\hspace{1mm} var = expr]{Assigne la valeur de l'expression à la variable}
\item[\hspace{1mm} var <op>=expr]{Est équivalent à "var = var <op> expr" à l'exception que var est évalué une seule fois. Peut faire une différence si var est un tableau}
\end{description}
 
\hspace{1mm}  Les expressions relationnels sont un type d'expression spécial qui s'évalue toujours à 1 ou 0. Les opérateurs relationnels sont:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} expr1 < expr2]{Le résultat est 1 si expr1 est strictement inférieur à expr2}
\item[\hspace{1mm} expr1 <= expr2]{Le résultat est 1 si expr1 est inférieur ou égal à expr2}
\item[\hspace{1mm} expr1 > expr2]{Le résultat est 1 si expr1 est strictement supérieur à expr2}
\item[\hspace{1mm} expr1 >= expr2]{Le résultat est 1 si expr1 est supérieur ou égal à expr2}
\item[\hspace{1mm} expr1 == expr2]{Le résultat est 1 si expr1 est égal à expr2}
\item[\hspace{1mm} expr1 != expr2]{Le résultat est 1 si expr1 est différent de expr2}
\end{description}
 
\hspace{1mm}  Les opérations booléennes sont aussi légales. Les opérations booléennes sont:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} !expr]{Le résultat est 1 si expr est 0}
\item[\hspace{1mm} expr \&\& expr]{Le résultat est 1 si les 2 expressions ne valent pas 0}
\item[\hspace{1mm} expr || expr]{Le résultat est 1 si au moins une des expressions ne vaut pas 0}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{1mm} ]{La précédence des expressions est la suivante:}
\item[\hspace{1mm} ||]{}
\item[\hspace{1mm} \&\&]{}
\item[\hspace{1mm} !]{}
\item[\hspace{1mm} Opérateurs relationnels]{}
\item[\hspace{1mm} Opérateurs d'assignement]{}
\item[\hspace{1mm} + et -]{}
\item[\hspace{1mm} \textasciicircum]{}
\item[\hspace{1mm} - unaire]{}
\item[\hspace{1mm} -- et ++]{}
\end{description}
 
\hspace{1mm}  Cette précédence à été choisie pour être conforme avec la version POSIX de bc. Cela occasionne quelques différences avec d'autres langages. par exemple, \textbf{a = 3 < 5} va assigner 3 à a puis comparer 3 à 5.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Fonctions spéciales }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} length ( expression )]{retourne le nombre de chiffres dans l'expression}
\item[\hspace{1mm} read ( )]{Lit un nombre sur l'entrée standard}
\item[\hspace{1mm} scale ( expression )]{retourne le nombre de chiffres aprés le point décimal dans l'expression}
\item[\hspace{1mm} sqrt ( expression )]{retourne la racine carré de l'expression. Si l'expression est négative, retourne une erreur}
\end{description}
 
\vspace{1cm}{\huge Déclarations }
 
\
 
\hspace{1mm}  Les déclarations fournissent le séquençage de l'évaluation d'expression. Dans bc les déclarations sont exécutés dès que possible. ';' et newline sont utilisés comme séparateur de déclaration. À cause de l'exécution immédiate, les newline sont très important. Il est possible de cacher un newline en utilisant un '\textbackslash{}'. La séquence "\textbackslash{}<nl>", où <nl> est le newline apparaît à bc comme un espace blanc au lieu d'un newline.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} expression]{Si l'expression commence avec "<variable> <assignement> ...", c'est considéré comme une déclaration d'assignement. Si l'expression n'est pas un assignement, elle est évaluée et affichée sur la sortie, suivi d'un newline.}
\item[\hspace{1mm} string]{La chaîne est affichée sur la sortie. Les chaînes sont entre '"'}
\item[\hspace{1mm} print list]{La déclaration print fournis une autre méthode de sortie. list est une liste de chaînes et d'expressions séparé par ','. Les expressions sont évaluées et leur valeur sont affichés et assigné à la variable last.}
\item[\hspace{1mm} \{ statement\_list \}]{Permet de regrouper les déclarations ensemble pour exécution}
\item[\hspace{1mm} if ( expression ) statement1 \texttt{[}else statement2\texttt{]}]{Évalue expression et exécute statement1 ou statement2 en fonction}
\item[\hspace{1mm} while ( expression ) statement]{Exécute la déclaration tant que expression est différent de 0}
\item[\hspace{1mm} for ( \texttt{[}expression1\texttt{]} ; \texttt{[}expression2\texttt{]} , \texttt{[}expression3\texttt{]} ) statement]{expression1 est évalué avant la boucle, expression2 est évalué avant chaque exécution de la déclaration, expression3 est évalué avant chaque ré-évaluation de expression2.}
\end{description}
 
\hspace{1mm} le code suivant est équivalent:
 
{\ttfamily
expression1;\\ while (expression2) \{\\ \hspace{2mm}statement,\\ \hspace{2mm}expression3;\\ \}\\
}
\vspace{8mm}
 
\begin{description} \normalsize
\item[\hspace{1mm} break]{Force à sortir d'une déclaration while ou for}
\item[\hspace{1mm} continue]{Force une nouvelle itération d'une déclaration for}
\item[\hspace{1mm} halt]{force à quitter bc}
\item[\hspace{1mm} return]{Retourne la valeur 0 depuis une fonction}
\item[\hspace{1mm} return ( expression )]{Retourne la valeur de l'expression depuis une fonction}
\end{description}
 
\vspace{1cm}{\huge Pseudo déclarations }
 
\
 
\hspace{1mm}  Ces déclarations ne sont pas exécutées, leur fonctions sont effectées à la compilation
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} limits]{Affiche les limites locales définis par la version de bc.}
\item[\hspace{1mm} quit]{Identique à halt' excepté qu'il est toujours effectué (ex: \textbf{if (0 = 1) quit} termine bc, ce qui n'est pas le cas de halt)}
\item[\hspace{1mm} warranty]{Affiche une note de garantie}
\end{description}
 
\vspace{1cm}{\huge Fonctions }
 
\
 
\hspace{1mm}  Les fonctions dans bc calculent toujours une valeur et la retourne à sont appelant. Les définitions des fonctions sont dynamiques dans le sens qu'une fonction est indéfinie jusqu'à ce qu'une définition soit rencontrée. Une nouvelle définition remplace la précédente.
\vspace{5mm} \\
 
 
\hspace{1mm} Une fontion est définie comme suit:
 
{\ttfamily
define name ( parameters ) \{ newline\\ \hspace{2mm}auto\_list statement\_list\\
}
\vspace{8mm}
 
\hspace{1mm}  Un appel de fonction est une simple déclaration sous la forme:
\vspace{5mm} \\
\hspace{1mm}  \textbf{"name(parameters)"}
\vspace{5mm} \\
\hspace{1mm}  Les paramètres sont des nombres ou des tableaux. Dans la définition de la fonction, on peut définir 0 ou plusieurs paramètres séparé par des virgules. Le nombre de paramètres doit correspondre lors de l'appel de la fonction.
\vspace{5mm} \\
\hspace{1mm}  \textbf{auto\_list} est une liste optionnelle de variables locales. La syntaxe est:\textbf{"auto name, ...;"}. Chaque name est le nom d'une auto variable. Ces variables sont initialisées à 0 et utilisées durant l'exécution de la fonction. Les auto variables sont différentes des variables locales traditionnelles parce que si une fonction A appel une fonction B, B peut accéder aux auto variables de A. Vue que bc push ces variables dans la pile, bc supporte les fonctions récursives
\vspace{5mm} \\
 
 
\hspace{1mm}  Le corp de la fonction est une liste de déclaration bc. return termine la fonction et retourne la valeur 0 à la fonction appelante, ou la valeur de l'expression, en fonction de la variante de return utilisée.
\vspace{5mm} \\
\hspace{1mm}  Les fonctions changene également l'utilisation de la variable \textbf{ibase}. Toutes les constantes dans le corp de la fonction seront convertis avec \textbf{ibase} au moment de l'appel de la fonction. Les changements de \textbf{ibase} seront ignorés durant l'exécution de la fonction excepté pour la fonction standard \textbf{read}.
\vspace{5mm} \\
 
 
\hspace{1mm}  De nombreuses extensions ont été ajoutés aux fonctions. Le format de la définition a été légèrement relaxé. Cette version de bc permet plusieurs newlines avant et après le'\{' ouvrante de la fonction.
\vspace{5mm} \\
 
 
\hspace{1mm} Par exemple, les définitions suivantes sont légales
 
{\ttfamily
define d (n) \{ return (2*n); \}\\ define d (n)\\ \{ return (2*n); \}\\
}
\vspace{8mm}
 
\hspace{1mm}  Les fonctions peuvent être définies en \textbf{void}. Cette fonction ne retourne pas de valeur. Le mot clé \textbf{void} est placé entre \textbf{define} et le nom de la fonction.
\vspace{5mm} \\
 
 
\hspace{1mm} Par exemple, la session suivante
 
{\ttfamily
define py (y) \{ print "--->", y, "<---", "0; \}\\ define void px (x) \{ print "--->", x, "<---", "0; \}\\ py(1)\\ --->1<---\\ 0\\ px(1)\\ --->1<---\\
}
\vspace{8mm}
 
\vspace{1cm}{\huge Librairie mathématique }
 
\
 
\hspace{1mm}  Si bc est invoqué avec l'option \textbf{-l}, une librairie mathématique est préchargée et l'échelle par défaut est 20. La librairie mathématique définis les fonctions suivantes:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} s (x)]{Le sinus de x, x est en radians}
\item[\hspace{1mm} c (x)]{Le cosinus de x, x est en radians}
\item[\hspace{1mm} a (x)]{Le arc tangente de x, retourne un radians}
\item[\hspace{1mm} l (x)]{Le logarithme naturel de x}
\item[\hspace{1mm} e (x)]{La fonction exponentiel du reste e à la valeur x}
\item[\hspace{1mm} j (n,x)]{La fonction Bessel de l'ordre entier n de x}
\end{description}
 
\vspace{1cm}{\huge Exemples }
 
\
 
\hspace{1mm} Dans /bin/sh, le code qui suit va assigner la valeur de "pi" à la variable shell pi \\
\hspace{1mm} \textbf{pi=\$(echo "scale=10; 4*a(1)" | bc -l)} \\
 
\hspace{1mm} La définition de la fonction exponentiel utilisée dans la librairie mathématique. et POSIX bc
 
{\ttfamily
scale = 20\\ \hspace{2mm}/*Uses the fact that e\textasciicircum x = (e\textasciicircum (x/2))\textasciicircum 2\\ When x is small enough, we use the series:\\ e\textasciicircum x = 1 + x + x\textasciicircum 2/2! + x\textasciicircum 3/3! + ...\\ */\\ \hspace{2mm}\\ define e(x) \{\\ \hspace{2mm}auto a, d, e, f, i, m, v, z\\ \hspace{2mm}\\ \hspace{2mm}/*Check the sign of x.*/\\ \hspace{2mm}if (x<0) \{\\ \hspace{2mm}\hspace{2mm}m = 1\\ \hspace{2mm}\hspace{2mm}x = -x\\ \hspace{2mm}\}\\ \hspace{2mm}\\ \hspace{2mm}/*Precondition x.*/\\ \hspace{2mm}z = scale;\\ \hspace{2mm}scale = 4 + z + .44*x;\\ \hspace{2mm}while (x > 1) \{\\ \hspace{2mm}\hspace{2mm}f += 1;\\ \hspace{2mm}\hspace{2mm}x /= 2;\\ \hspace{2mm}\}\\
}
\vspace{8mm}
 
{\ttfamily
/*Initialize the variables.*/\\ \hspace{2mm}v = 1+x\\ \hspace{2mm}a = x\\ \hspace{2mm}d = 1\\ \hspace{2mm}\\ \hspace{2mm}for (i=2; 1; i++) \{\\ \hspace{2mm}\hspace{2mm}e = (a *= x) / (d *= i)\\ \hspace{2mm}\hspace{2mm}if (e == 0) \{\\ \hspace{2mm}\hspace{2mm}\hspace{2mm}if (f>0) while (f--) v = v*v;\\ \hspace{2mm}\hspace{2mm}\hspace{2mm}scale = z\\ \hspace{2mm}\hspace{2mm}\hspace{2mm}if (m) return (1/v);\\ \hspace{2mm}\hspace{2mm}\hspace{2mm}return (v/1);\\ \hspace{2mm}\hspace{2mm}\}\\ \hspace{2mm}\hspace{2mm}v += e\\ \hspace{2mm}\}\\ \}\\
}
\vspace{8mm}
 
\hspace{1mm} ce code utilise les extensions bc pour implémenter un simple programme de calcul de solde de chéquiers
 
{\ttfamily
scale=2\\ print "\textbackslash{}nCheck book program!\textbackslash{}n"\\ print " Remember, deposits are negative transactions.\textbackslash{}n"\\ print " Exit by a 0 transaction.\textbackslash{}n\textbackslash{}n"\\ print "Initial balance? "; bal = read()\\ bal /= 1\\ print "\textbackslash{}n"\\ while (1) \{\\ \hspace{2mm}"current balance = "; bal\\ \hspace{2mm}"transaction? "; trans = read()\\ \hspace{2mm}if (trans == 0) break;\\ \hspace{2mm}bal -= trans\\ \hspace{2mm}bal /= 1\\ \}\\ quit\\
}
\vspace{8mm}
 
\hspace{1mm} Définition d'une fonction factorielle récursive
 
{\ttfamily
define f (x) \{\\ \hspace{2mm}if (x <= 1) return (1);\\ \hspace{2mm}return (f(x-1)\hspace{2mm}*\hspace{2mm}x);\\ \}\\
}
\vspace{8mm}
 
\vspace{1cm}{\huge Options Readline et Libedit }
 
\
 
\hspace{1mm}  GNU bc peut être compilé pour utiliser la librairie d'entrée GNU readline ou BSD libedit. Cela permet à l'utilisateur d'éditer les lignes avant de les envoyer à bc. Cela permet également de conserver un historique. Quand cette option est sélectionné, bc a une variable spéciale supplémentaire, \textbf{history}
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Limites }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} ]{Les limites suivantes sont dans le pré-processeur bc. max input base: 16}
\item[\hspace{1mm} BC\_BASE\_MAX]{base de sortie max, défaut: 999.}
\item[\hspace{1mm} BC\_DIM\_MAX]{Limite arbitraire de 65535}
\item[\hspace{1mm} BC\_SCALE\_MAX]{Le nombre de chiffres avant et après la virgule sont chacun limité par INT\_MAX}
\item[\hspace{1mm} BC\_STRING\_MAX]{La limite du nombre de caractères dans une chaîne est de INT\_MAX caractères}
\item[\hspace{1mm} exponent]{La valeur de l'exposant (\textasciicircum ) est limité à LONG\_MAX}
\item[\hspace{1mm} variable names]{La limite du nombre de noms unique est de 32767 pour chaque variable simples, tableaux et fonctions}
\end{description}
 
\vspace{1cm}{\huge Variables d'environnement }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} POSIXLY\_CORRECT]{Identique à -s, conforme bc à POSIX}
\item[\hspace{1mm} BC\_ENV\_ARGS]{Autre mécanisme pour donner les arguments à bc, ces arguments sont traités en premier}
\item[\hspace{1mm} BC\_LINE\_LENGTH]{Spécifie le nombres de caractères sur une ligne de sortie. À 0, désactive la sortie multi-ligne. Une valeur inférieur à 3 définis la longueur de ligne à 70}
\end{description}
\end{flushleft}
\end{document}
