Traduction manuel de wxMaxima - en to fr translation catalogue (289 entries)

note: type: Plain text
en: # The wxMaxima user manual
fr: # Manuel de l'utilisateur de wxMaxima

note: type: Plain text
en: WxMaxima is a graphical user interface (GUI) for the _Maxima_ computer algebra system (CAS). WxMaxima allows one to use all of _Maxima_’s functions. In addition, it provides convenient wizards for accessing the most commonly used features. This manual describes some of the features that make wxMaxima one of the most popular GUIs for _Maxima_.
fr: WxMaxima est une interface graphique (GUI) pour le système de calcul formel (CAS) _Maxima_.  WxMaxima permet d’utiliser toutes les fonctions de _Maxima_. De plus, il fournit des assistants pratiques pour accéder aux fonctionnalités les plus couramment utilisées. Ce manuel décrit certaines des caractéristiques qui font de wxMaxima l’une des interfaces graphiques les plus populaires pour _Maxima_.

note: type: Plain text
en: # Introduction to wxMaxima
fr: # Présentation de wxMaxima

note: type: Plain text
en: ## _Maxima_ and wxMaxima
fr: ## _Maxima_ et wxMaxima

note: type: Plain text
en: In the open-source domain, big systems are normally split into smaller projects that are easier to handle for small groups of developers. For example a CD burner program will consist of a command-line tool that actually burns the CD and a graphical user interface that allows users to implement it without having to learn about all the command line switches and in fact without using the command line at all. One advantage of this approach is that the developing work that was invested into the command-line program can be shared by many programs: The same CD-burner command-line program can be used as a “send-to-CD”-plug-in for a file manager application, for the “burn to CD” function of a music player and as the CD writer for a DVD backup tool. Another advantage is that splitting one big task into smaller parts allows the developers to provide several user interfaces for the same program.
fr: Dans le domaine open-source, les grands systèmes sont généralement divisés en projets plus petits, plus faciles à gérer pour de petits groupes de développeurs. Par exemple, un programme de gravure de CD peut se composer d’un outil en ligne de commande qui effectue réellement la gravure du CD, et d’une interface graphique permettant aux utilisateurs de l’utiliser sans avoir à apprendre toutes les options de la ligne de commande, voire sans jamais y recourir. Un avantage de cette méthode est que le travail de développement réalisé dans le programme en ligne de commande peut être partagé par de nombreuses applications : le même programme de gravure en ligne de commande peut servir de module "Envoyer vers un CD",  pour un gestionnaire de fichiers, de fonction "Graver sur CD" pour un lecteur multimédia, ou encore de graveur de CD pour un outil de sauvegarde sur DVD. Un autre avantage est que la division d’une tâche complexe en parties plus réduites permet aux développeurs de proposer plusieurs interfaces utilisateur pour un même programme.

note: type: Plain text
en: A computer algebra system (CAS) like _Maxima_ fits into this framework. A CAS can provide the logic behind an arbitrary precision calculator application or it can do automatic transforms of formulas in the background of a bigger system (e.g., [Sage](https://www.sagemath.org/)). Alternatively, it can be used directly as a free-standing system. _Maxima_ can be accessed via a command line. Often, however, an interface like _wxMaxima_ proves a more efficient way to access the software, especially for newcomers.
fr: Un système de calcul formel (CAS) comme _Maxima_ s'intègre dans ce cadre. Un CAS peut fournir la logique derrière une application de type calculatrice à précision arbitraire ou effectuer des transformations automatiques de formules en arrière-plan d'un système plus large (par exemple, [Sage](https://www.sagemath.org/)). Alternativement, il peut être utilisé directement comme un logiciel autonome. _Maxima_ peut être accessible via une ligne de commande. Cependant, une interface comme _wxMaxima_ s'avère souvent un moyen plus efficace d'accéder au logiciel, surtout pour les nouveaux utilisateurs.

note: type: Plain text
en: _Maxima_ is a full-featured computer algebra system (CAS). A CAS is a program that can solve mathematical problems by rearranging formulas and finding a formula that solves the problem as opposed to just outputting the numeric value of the result. In other words, _Maxima_ can serve as a calculator that gives numerical representations of variables, and it can also provide analytical solutions. Furthermore, it offers a range of numerical methods of analysis for equations or systems of equations that cannot be solved analytically.
fr: _Maxima_ est un système complet de calcul formel (CAS). Un CAS est un programme capable de résoudre des problèmes mathématiques en manipulant des formules et en retournant des expressions algébriques qui résolvent le problème, plutôt que de simplement fournir une valeur numérique du résultat. Autrement dit, _Maxima_ peut fonctionner comme une calculatrice qui donne  des valeurs numériques des variables, mais il peut aussi fournir des solutions analytiques formelles. De plus, il propose une gamme de méthodes numériques pour analyser des équations ou des systèmes d’équations qui ne peuvent pas être résolus de manière formelle.

note: type: Plain text
en: ![Maxima screenshot, command line](./maxima_screenshot.png){ id=img_maxima_screenshot }
fr: ![Copie d'écran Maxima, ligne de commande](./maxima_screenshot.png){ id=img_maxima_screenshot }

note: type: Plain text
en: Extensive documentation for _Maxima_ is [available in the internet](https://maxima.sourceforge.io/documentation.html). Part of this documentation is also available in wxMaxima’s help menu. Pressing the Help key (on most systems the <kbd>F1</kbd> key) causes _wxMaxima_’s context-sensitive help feature to automatically jump to _Maxima_’s manual page for the command at the cursor.
fr: Une documentation complète pour _Maxima_ est [disponible en ligne](https://maxima.sourceforge.io/documentation.html). Une partie de cette documentation est également accessible via le menu d’aide de wxMaxima. En appuyant sur la touche d’aide (généralement la touche <kbd>F1</kbd> sur la plupart des systèmes), la fonction d’aide contextuelle de _wxMaxima_ ouvre automatiquement la page du manuel de _Maxima_ correspondant à la commande située sous le curseur.

note: type: Plain text
en: _WxMaxima_ is a graphical user interface that provides the full functionality and flexibility of _Maxima_. WxMaxima offers users a graphical display and many features that make working with _Maxima_ easier. For example _wxMaxima_ allows one to export any cell’s contents (or, if that is needed, any part of a formula, as well) as text, as LaTeX or as MathML specification at a simple right-click. Indeed, an entire workbook can be exported, either as a HTML file or as a LaTeX file. Documentation for _wxMaxima_, including workbooks to illustrate aspects of its use, is online at the _wxMaxima_ [help site](https://wxMaxima-developers.github.io/wxmaxima/help.html), as well as via the help menu.
fr: _WxMaxima_ est une interface graphique qui offre toute les fonctionnalités et la flexibilité de _Maxima_. WxMaxima propose aux utilisateurs un affichage graphique ainsi que de nombreuses fonctionnalités qui facilitent l’utilisation de _Maxima_. Par exemple, _wxMaxima_ permet d’exporter le contenu de n’importe quelle cellule (ou, si nécessaire, une partie d’une formule) sous forme de texte, de code LaTeX ou de codage MathML, simplement en effectuant un clic droit. En outre, un notebook entier peut être exporté, soit en tant que fichier HTML, soit en tant que fichier LaTeX. La documentation de _wxMaxima_, incluant des notebooks d’exemples illustrant ses différentes fonctionnalités, est disponible en ligne sur le [site d’aide de wxMaxima](https://wxMaxima-developers.github.io/wxmaxima/help.html), ainsi que via le menu d’aide.

note: type: Plain text
en: ![wxMaxima window](./wxMaximaWindow.png){ id=img_wxMaximaWindow }
fr: ![fenêtre de wxMaxima](./wxMaximaWindow.png){ id=img_wxMaximaWindow }

note: type: Plain text
en: The calculations that are entered in _wxMaxima_ are performed by the _Maxima_ command-line tool in the background.
fr: Les calculs saisis dans _wxMaxima_ sont exécutés en arrière-plan par l'outil en ligne de commande _Maxima_.

note: type: Plain text
en: ## Workbook basics
fr: ## Notions de base d'un notebook

note: type: Plain text
en: Much of _wxMaxima_ is self-explaining, but some details require attention. [This site](https://wxMaxima-developers.github.io/wxmaxima/help.html) contains a number of workbooks that address various aspects of _wxMaxima_. Working through some of these (particularly the "10 minute _(wx)Maxima_ tutorial") will increase one’s familiarity with both the content of _Maxima_ and the use of _wxMaxima_ to interact with _Maxima_. This manual concentrates on describing aspects of _wxMaxima_ that are not likely to be self-evident and that might not be covered in the online material.
fr: Une grande partie de wxMaxima est intuitive, mais certains détails nécessitent une attention particulière. [Ce site](https://wxMaxima-developers.github.io/wxmaxima/help.html) contient plusieurs notebooks qui abordent divers aspects de _wxMaxima_. Parcourir certains d’entre eux (notamment le « tutoriel de 10 minutes sur (wx)Maxima ») permettra de mieux maîtriser à la fois le contenu de _Maxima_ et l’utilisation de _wxMaxima_ pour interagir avec _Maxima_. Ce manuel se concentre sur la description des aspects de _wxMaxima_ qui ne sont pas nécessairement évidents et qui pourraient ne pas être présentés dans les ressources en ligne.

note: type: Plain text
en: ### The workbook approach
fr: ### Fondamentaux du notebook

note: type: Plain text
en: One of the very few things that are not standard in _wxMaxima_ is that it organizes the data for _Maxima_ into cells that are evaluated (which means: sent to _Maxima_) only when the user requests this. When a cell is evaluated, all commands in that cell, and only that cell, are evaluated as a batch. (The preceding statement is not quite accurate: One can select a set of adjacent cells and evaluate them together. Also, one can instruct _Maxima_ to evaluate all cells in a workbook in one pass.) _WxMaxima_’s approach to submitting commands for execution might feel unfamiliar at the first sight. It does, however, drastically ease work with big documents (where the user does not want every change to automatically trigger a full re-evaluation of the whole document). Also, this approach is very handy for debugging.
fr: L'une des très rares choses qui ne sont pas standard avec _wxMaxima_ est qu'il organise les données pour _Maxima_ en cellules qui ne sont évaluées (c'est-à-dire envoyées à _Maxima_) que lorsque l'utilisateur le demande. Lorsqu'une cellule est évaluée, toutes les commandes de cette cellule, et uniquement de cette cellule, sont évaluées en bloc. (La phrase précédente n'est pas tout à fait exacte : on peut sélectionner un ensemble de cellules adjacentes et les évaluer ensemble. On peut aussi demander à _Maxima_ d'évaluer toutes les cellules d'un notebook  en une seule fois.) L'approche de _wxMaxima_ pour exécuter les commandes peut sembler inhabituelle au premier abord. Elle facilite cependant grandement le travail avec de grands documents (où l'utilisateur ne souhaite pas que chaque modification déclenche automatiquement une réévaluation complète de l'ensemble du document). De plus, cette approche est très pratique pour le débogage.

note: type: Plain text
en: If text is typed into _wxMaxima_ it automatically creates a new worksheet cell. The type of this cell can be selected in the toolbar. If a code cell is created the cell can be sent to _Maxima_, which causes the result of the calculation to be displayed below the code. A pair of such commands is shown below.
fr: Si du texte est saisi dans _wxMaxima_, une nouvelle cellule est automatiquement créée dans le notebook. Le type de cette cellule peut être sélectionné dans la barre d'outils. Si une cellule de code est créée, elle peut être envoyée à _Maxima_, ce qui affiche le résultat du calcul en dessous du code. Une paire de ce type de commandes est présentée ci-dessous.

note: type: Plain text
en: ![Input/output cell](./InputCell.png){ id=img_InputCell }
fr: ![Cellules entrée/sortie cell](./InputCell.png){ id=img_InputCell }

note: type: Plain text
en: On evaluation of an input cell’s contents the input cell _Maxima_ assigns a label to the input (by default shown in red and recognizable by the `%i`) by which it can be referenced later in the _wxMaxima_ session. The output that _Maxima_ generates also gets a label that begins with `%o` and by default is hidden, except if the user assigns the output a name. In this case by default the user-defined label is displayed. The `%o`-style label _Maxima_ auto-generates will also be accessible, though.
fr: Lors de l’évaluation du contenu d’une cellule d’entrée, _Maxima_ attribue un identifiant à l’entrée (affiché par défaut en rouge et reconnaissable par le `%i`), ce qui permet d’y faire référence plus tard dans la session _wxMaxima_. La sortie générée par _Maxima_ reçoit également un identifiant commençant par `%o`, masqué par défaut, sauf si l’utilisateur attribue un nom à cette sortie. Dans ce cas, l’identifiant défini par l’utilisateur s’affiche par défaut, mais l’identifiant automatique de type `%o` reste accessible.

note: type: Plain text
en: Besides the input cells _wxMaxima_ allows for text cells for documentation, image cells, title cells, chapter cells and section cells. Every cell has its own undo buffer so debugging by changing the values of several cells and then gradually reverting the unneeded changes is rather easy. Furthermore the worksheet itself has a global undo buffer that can undo cell edits, adds and deletes.
fr: Outre les cellules d’entrée, _wxMaxima_ permet d’insérer des cellules de texte pour la documentation, des cellules d’image, des cellules de titre, de chapitre et de section. Chaque cellule dispose de son propre historique d’annulation, ce qui facilite le débogage en modifiant les valeurs de plusieurs cellules puis en annulant progressivement les changements inutiles. De plus, le notebook en lui-même possède un historique d’annulation global qui permet d’annuler les modifications, ajouts et suppressions de cellules.

note: type: Plain text
en: The figure below shows different cell types (title cells, section cells, subsection cells, text cells, input/output cells and image cells).
fr: La figure ci-dessous montre différents types de cellules (cellules de titre, cellules de section, cellules de sous-section, cellules de texte, cellules d’entrée/sortie et cellules d’image).

note: type: Plain text
en: ![Example of different wxMaxima cells](./cell-example.png){ id=img_cell-example }
fr: ![Exemple de cellules différentes de wxMaxima](./cell-example.png){ id=img_cell-example }

note: type: Plain text
en: ### Cells
fr: ### Cellules

note: type: Plain text
en: The worksheet is organized in cells. WxMaxima knows the following cell types:
fr: Le notebook est organisé en cellules. WxMaxima distingue les types de cellules suivants  :

note: type: Plain text
en: The default behavior of _wxMaxima_ when text is entered is to automatically create a math cell. Cells of other types can be created using the Cell menu, using the hot keys shown in the menu or using the drop-down list in the toolbar. Once the non-math cell is created, whatever is typed into the file is interpreted as text.
fr: Par défaut, _wxMaxima_ crée automatiquement une cellule de calcul lorsque du texte est saisi. Pour créer des cellules d’un autre type, utilisez le menu Cellule, les raccourcis clavier indiqués dans ce menu ou la liste déroulante de la barre d’outils. Une fois qu’une cellule non mathématique est créée, tout ce qui y est saisi est interprété comme du texte.

note: type: Plain text
en: A (C-style) [comment text](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#Comments) can be part of a math cell as follows: `/* This comment will be ignored by Maxima */`
fr: Un [commentaire (style C)](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#Comments) peut être inséré dans une cellule de calcul comme suit : `/* Ce commentaire sera ignoré par Maxima */`

note: type: Plain text
en: "`/*`" marks the start of the comment, "`*/`" the end.
fr: "`/*`" indique le début du commentaire, "`*/`" la fin.

note: type: Plain text
en: ### Horizontal and vertical cursors
fr: ### curseurs horizontaux et verticaux

note: type: Plain text
en: If the user tries to select a complete sentence, a word processor will try to extend the selection to automatically begin and end with a word boundary. Likewise, if more than one cell is selected, _wxMaxima_ will extend the selection to whole cells.
fr: Si l’utilisateur tente de sélectionner une phrase complète, un traitement de texte étendra automatiquement la sélection pour qu’elle commence et se termine aux limites d’un mot. De même, si plusieurs cellules sont  sélectionnées, _wxMaxima_ étendra la sélection aux cellules entières.

note: type: Plain text
en: What isn’t standard is that _wxMaxima_ provides drag-and-drop flexibility by defining two types of cursors. _WxMaxima_ will switch between them automatically when needed:
fr: Ce qui est moins conventionnel, c’est que _wxMaxima_ offre une facilité de glisser-déposer en définissant deux types de curseurs. _wxMaxima_ basculera automatiquement entre eux selon le besoin :

note: type: Plain text
en: When you start wxMaxima, you will only see the blinking horizontal cursor. If you start typing, a math cell will be automatically created and the cursor will change to a regular vertical one (you will see a right arrow as "prompt", after the Math cell is evaluated (<kbd>CTRL</kbd>+<kbd>ENTER</kbd>), you will see the labels, e.g. `(%i1)`, `(%o1)`).
fr: Quand vous lancez wxMaxima, vous ne verrez que le curseur horizontal clignotant. Si vous commencez à taper, une cellule mathématique sera automatiquement créée et le curseur deviendra un curseur vertical classique (vous verrez une flèche vers la droite comme "invite", et après avoir évalué la cellule mathématique (<kbd>CTRL</kbd>+<kbd>ENTRÉE</kbd>), les étiquettes apparaîtront, par exemple `(%i1)`, `(%o1)`.

note: type: Plain text
en: ![(blinking) horizontal cursor after wxMaxima start](./horizontal-cursor-only.png){ id=img_horizontal_cursor_only }
fr: ![curseur horizontal (clignotant) après le démarrage de wxMaxima](./horizontal-cursor-only.png){ id=img_horizontal_cursor_only }

note: type: Plain text
en: You might want to create a different cell type (using the "Cell" menu), maybe a title cell or text cell, which describes, what will be done, when you start creating your worksheet.
fr: Vous pourrez peut-être vouloir créer un type de cellule différent (via le menu "Cellule"), comme une cellule de titre ou une cellule de texte, pour décrire ce que vous allez faire lorsque vous commencerez à créer votre notebook.

note: type: Plain text
en: If you navigate between the different cells, you will also see the (blinking) horizontal cursor, where you can insert a cell into your worksheet (either a math cell, by just start typing your formula - or a different cell type using the menu).
fr: Si vous naviguez entre les différentes cellules, vous verrez également le curseur horizontal (clignotant), indiquant l'endroit où vous pouvez insérer une nouvelle cellule dans votre notebook (soit une cellule mathématique, en commençant simplement à saisir votre formule, soit un autre type de cellule en utilisant le menu).

note: type: Plain text
en: ![(blinking) horizontal cursor between cells](./horizontal-cursor-between-cells.png){ id=img_horizontal_cursor_between_cells }
fr: ![curseur horizontal (clignotant) entre deux cellules](./horizontal-cursor-between-cells.png){ id=img_horizontal_cursor_between_cells }

note: type: Plain text
en: ### Sending cells to Maxima
fr: ### Envoyer des cellules à Maxima

note: type: Plain text
en: The command in a code cell is executed once by pressing <kbd>CTRL</kbd>+<kbd>ENTER</kbd>, <kbd>SHIFT</kbd>+<kbd>ENTER</kbd> or the <kbd>ENTER</kbd> key on the keypad. The _wxMaxima_ default is to enter commands when either <kbd>CTRL</kbd>+<kbd>ENTER</kbd> or <kbd>SHIFT</kbd>+<kbd>ENTER</kbd> is entered, but _wxMaxima_ can be configured to execute commands in response to <kbd>ENTER</kbd>.
fr: La commande dans une cellule de code est exécutée en appuyant une fois sur <kbd>CTRL</kbd>+<kbd>ENTRÉE</kbd>, <kbd>MAJ</kbd>+<kbd>ENTRÉE</kbd> ou la touche <kbd>ENTRÉE</kbd> du pavé numérique. Par défaut, _wxMaxima_ exécute les commandes lorsque <kbd>CTRL</kbd>+<kbd>ENTRÉE</kbd> ou <kbd>MAJ</kbd>+<kbd>ENTRÉE</kbd> est pressé, mais il est possible de configurer _wxMaxima_ pour qu’il exécute les commandes en réponse à la touche <kbd>ENTRÉE</kbd>.

note: type: Plain text
en: ### Command autocompletion
fr: ### Complétion automatique des commandes

note: type: Plain text
en: _WxMaxima_ contains an autocompletion feature that is triggered via the menu (Cell/Complete Word) or alternatively by pressing the key combination <kbd>CTRL</kbd>+<kbd>SPACE</kbd>. The autocompletion is context-sensitive. For example, if activated within a unit specification for ezUnits it will offer a list of applicable units.
fr: _wxMaxima_ dispose d’une fonction de complétion automatique, accessible via le menu (Cellule/Compléter le mot) ou en appuyant sur la combinaison de touches <kbd>CTRL</kbd>+<kbd>ESPACE</kbd>. Cette complétion est sensible au contexte : par exemple, si elle est activée lors d'une spécification d’unité pour ezUnits, elle proposera une liste des unités applicables.

note: type: Plain text
en: Besides completing a file name, a unit name, or the current command or variable name, the autocompletion is able to show a template for most of the commands indicating the type (and meaning) of the parameters this program expects. To activate this feature press <kbd>SHIFT</kbd>+<kbd>CTRL</kbd>+<kbd>SPACE</kbd> or select the respective menu item (Cell/Show Template).
fr: Outre la complétion des noms de fichiers, d’unités, de commandes ou de variables, la complétion automatique peut aussi afficher un modèle pour la plupart des commandes, indiquant le type (et la signification) des paramètres attendus par le programme. Pour activer cette fonctionnalité, appuyez sur <kbd>MAJ</kbd>+<kbd>CTRL</kbd>+<kbd>ESPACE</kbd> ou sélectionnez l’option correspondante dans le menu (Cellule/Afficher le modèle).

note: type: Plain text
en: #### Greek characters
fr: #### Caractères grecs

note: type: Plain text
en: Computers traditionally stored characters in 8-bit values. This allows for a maximum of 256 different characters. All letters, numbers, and control symbols (end of transmission, end of string, lines and edges for drawing rectangles for menus _etc_.) of nearly any given language can fit within that limit.
fr: Traditionnellement, les ordinateurs stockaient les caractères sur 8 bits, ce qui permet un maximum de 256 caractères différents. Toutes les lettres, chiffres et symboles de contrôle (fin de transmission, fin de chaîne, lignes et bordures pour dessiner des rectangles autour des menus, etc.) de presque n'importe quelle langue pouvaient tenir avec cette limite.

note: type: Plain text
en: For most countries, the codepage of 256 characters that has been chosen does not include things like Greek letters, though, that are frequently used in mathematics. To overcome this type of limitation [Unicode](https://home.unicode.org/) has been invented: An encoding that makes English text work like normal, but to use much more than 256 characters.
fr: Pour la plupart des pays, la page de codes de 256 caractères choisie n'inclut cependant pas des éléments comme les lettres grecques, pourtant fréquemment utilisées en mathématiques. Pour surmonter ce type de limitation, [Unicode](https://home.unicode.org/) a été inventé : il s'agit d'un encodage qui permet aux textes en anglais de s'afficher normalement, tout en utilisant bien plus que 256 caractères.

note: type: Plain text
en: _Maxima_ allows Unicode if it was compiled using a Lisp compiler that either supports Unicode or that doesn’t care about the font encoding. As at least one of this pair of conditions is likely to be true. _WxMaxima_ provides a method of entering Greek characters using the keyboard:
fr: _Maxima_ prend en charge Unicode s'il a été compilé avec un compilateur Lisp qui supporte Unicode ou qui ne tient pas compte de l'encodage de la police. Comme au moins une de ces deux conditions est probablement remplie, _wxMaxima_ fournit une méthode pour saisir des caractères grecs à l'aide du clavier :

note: type: Plain text
en: | key | Greek letter | key | Greek letter | key | Greek letter |
    | :-: | :----------: | :-: | :----------: | :-: | :----------: |
    |  a  |    alpha     |  i  |     iota     |  r  |     rho      |
    |  b  |     beta     |  k  |    kappa     |  s  |    sigma     |
    |  g  |    gamma     |  l  |    lambda    |  t  |     tau      |
    |  d  |    delta     |  m  |      mu      |  u  |   upsilon    |
    |  e  |   epsilon    |  n  |      nu      |  f  |     phi      |
    |  z  |     zeta     |  x  |      xi      |  c  |     chi      |
    |  h  |     eta      | om  |   omicron    |  y  |     psi      |
    |  q  |    theta     |  p  |      pi      |  o  |    omega     |
    |  A  |    Alpha     |  I  |     Iota     |  R  |     Rho      |
    |  B  |     Beta     |  K  |    Kappa     |  S  |    Sigma     |
    |  G  |    Gamma     |  L  |    Lambda    |  T  |     Tau      |
    |  D  |    Delta     |  M  |      Mu      |  U  |   Upsilon    |
    |  E  |   Epsilon    |  N  |      Nu      |  P  |     Phi      |
    |  Z  |     Zeta     |  X  |      Xi      |  C  |     Chi      |
    |  H  |     Eta      | Om  |   Omicron    |  Y  |     Psi      |
    |  T  |    Theta     |  P  |      Pi      |  O  |    Omega     |
fr: | touche | Lettre grecque | touche | Lettre grecque | touche | Lettre grecque |
    | :-: | :----------: | :-: | :----------: | :-: | :----------: |
    |  a  |    alpha     |  i  |     iota     |  r  |     rho      |
    |  b  |     beta     |  k  |    kappa     |  s  |    sigma     |
    |  g  |    gamma     |  l  |    lambda    |  t  |     tau      |
    |  d  |    delta     |  m  |      mu      |  u  |   upsilon    |
    |  e  |   epsilon    |  n  |      nu      |  f  |     phi      |
    |  z  |     zeta     |  x  |      xi      |  c  |     chi      |
    |  h  |     eta      | om  |   omicron    |  y  |     psi      |
    |  q  |    theta     |  p  |      pi      |  o  |    omega     |
    |  A  |    Alpha     |  I  |     Iota     |  R  |     Rho      |
    |  B  |     Beta     |  K  |    Kappa     |  S  |    Sigma     |
    |  G  |    Gamma     |  L  |    Lambda    |  T  |     Tau      |
    |  D  |    Delta     |  M  |      Mu      |  U  |   Upsilon    |
    |  E  |   Epsilon    |  N  |      Nu      |  P  |     Phi      |
    |  Z  |     Zeta     |  X  |      Xi      |  C  |     Chi      |
    |  H  |     Eta      | Om  |   Omicron    |  Y  |     Psi      |
    |  T  |    Theta     |  P  |      Pi      |  O  |    Omega     |

note: type: Plain text
en: You can also use the "Greek letters"-sidebar to enter the Greek letters.
fr: Vous pouvez également utiliser la barre latérale « Lettres grecques » pour insérer les lettres grecques.

note: type: Plain text
en: ##### Attention: Lookalike characters
fr: ##### Attention aux caractères similaires

note: type: Plain text
en: Several Latin letters look like the Greek letters, e.g. the Latin letter "A" and the Greek letter "Alpha". Although they look identical, they are two different Unicode characters, represented by different Unicode code points (numbers).
fr: Plusieurs lettres latines ressemblent aux lettres grecques, par exemple la lettre latine "A" et la lettre grecque "Alpha". Bien qu'elles aient la même apparence, ce sont deux caractères Unicode distincts, représentés par des codages Unicode (nombres) différents.

note: type: Plain text
en: This might be problematic, if you assign a value to the variable A and later use the Greek letter Alpha to do something with this variable, especially on printouts.  For the Greek letter my (which is also used as prefix for micro) there are also two different Unicode code points.
fr: Cela peut poser problème si vous attribuez une valeur à la variable A et que vous utilisez ensuite la lettre grecque Alpha pour faire quelque chose avec cette variable, notamment sur les impressions. Pour la lettre grecque mu (utilisée aussi comme préfixe pour micro), il existe également deux codages Unicode différents.

note: type: Plain text
en: The "Greek letters"-sidebar therefore has the option, that lookalike characters are not available (which can be changed using a right-click menu).
fr: La barre latérale « Lettres grecques » offre donc l’option de désactiver les caractères similaires (ce paramètre peut être modifié via un menu accessible par un clic droit).

note: type: Plain text
en: The same mechanism also allows to enter some miscellaneous mathematical symbols:
fr: Le même mécanisme permet également de saisir divers symboles mathématiques :

note: type: Plain text
en: | keys to enter  | mathematical symbol                                   |
    | -------------- | ----------------------------------------------------- |
    | hbar           | Planck constant: a h with a horizontal bar above it   |
    | Hbar           | a H with a horizontal bar above it                    |
    | 2              | squared                                               |
    | 3              | to the power of three                                 |
    | /2             | 1/2                                                   |
    | partial        | partial sign (the d of dx/dt)                         |
    | integral       | integral sign                                         |
    | sq             | square root                                           |
    | ii             | imaginary                                             |
    | ee             | element                                               |
    | in             | in                                                    |
    | impl implies   | implies                                               |
    | inf            | infinity                                              |
    | empty          | empty                                                 |
    | TB             | big triangle right                                    |
    | tb             | small triangle right                                  |
    | and            | and                                                   |
    | or             | or                                                    |
    | xor            | xor                                                   |
    | nand           | nand                                                  |
    | nor            | nor                                                   |
    | equiv          | equivalent to                                         |
    | not            | not                                                   |
    | union          | union                                                 |
    | inter          | intersection                                          |
    | subseteq       | subset or equal                                       |
    | subset         | subset                                                |
    | notsubseteq    | not subset or equal                                   |
    | notsubset      | not subset                                            |
    | approx         | approximately                                         |
    | propto         | proportional to                                       |
    | neq != /= or # | not equal to                                          |
    | +/- or pm      | a plus/minus sign                                     |
    | \<= or leq     | equal or less than                                    |
    | >= or geq      | equal or greater than                                 |
    | \<\< or ll     | much less than                                        |
    | >> or gg       | much greater than                                     |
    | qed            | end of proof                                          |
    | nabla          | a nabla operator                                      |
    | sum            | sum sign                                              |
    | prod           | product sign                                          |
    | exists         | there exists sign                                     |
    | nexists        | there is no sign                                      |
    | parallel       | a parallel sign                                       |
    | perp           | a perpendicular sign                                  |
    | leadsto        | a leads to sign                                       |
    | ->             | a right arrow                                         |
    | -->            | a long right arrow                                    |
fr: Touches à saisir | symbole mathématique                                            |
    |---------------|-----------------------------------------------------------------|
    | hbar           | Constante de Planck : un h avec une barre horizontale au-dessus |
    | Hbar           | un H avec une barre horizontale au-dessus                       |
    | 2              | au carré                                                        |
    | 3              | à la puissance trois                                            |
    | /2             | 1/2                                                             |
    | partial        | symbole de dérivation partielle (le d de dx/dt)                 |
    | integral       | symbole intégrale                                               |
    | sq             | racine carrée                                                   |
    | ii             | imaginaire                                                      |
    | ee             | appartient à                                                    |
    | in             | dans                                                            |
    | impl implies   | implique                                                        |
    | inf            | infini                                                          |
    | empty          | ensemble vide                                                   |
    | TB             | grand triangle vers la droite                                   |
    | tb             | petit triangle vers la droite                                   |
    | and            | et                                                              |
    | or             | ou                                                              |
    | xor            | ou exclusif                                                     |
    | nand           | et non                                                          |
    | nor            | ni                                                              |
    | equiv          | équivalent à                                                    |
    | not            | non                                                             |
    | union          | union                                                           |
    | inter          | intersection                                                    |
    | subseteq       | sous-ensemble ou égal                                           |
    | subset         | sous-ensemble                                                   |
    | notsubseteq    | n'est pas un  sous-ensemble ou égal                             |
    | notsubset      | n'est pas un sous-ensemble                                      |
    | approx         | approximativement                                               |
    | propto         | proportionnel à                                                 |
    | neq != /= ou # | différent de                                                    |
    | +/- ou pm      | signe plus/moins                                                |
    | \<= ou leq     | inférieur ou égal à                                             |
    | >= ou geq      | supérieur ou égal à                                             |
    | \<\< ou ll     | beaucoup plus petit que                                         |
    | >> ou gg       | beaucoup plus grand que                                         |
    | qed            | fin de preuve                                                   |
    | nabla          | opérateur nabla                                                 |
    | sum            | symbole somme                                                   |
    | prod           | symbole produit                                                 |
    | exists         | il existe                                                       |
    | nexists        | il n'existe pas                                                 |
    | parallel       | symbole parallèle                                               |
    | perp           | symbole perpendiculaire                                         |
    | leadsto        | symbole mène à                                                  |
    | ->             | flèche vers la droite                                           |
    | -->            | longue flèche vers la droite                                    |

note: type: Plain text
en: You can also use the "Symbols"-sidebar to enter these Mathematical symbols.
fr: Vous pouvez aussi utiliser la barre latérale « Symboles » pour saisir ces symboles mathématiques.

note: type: Plain text
en: If a special symbol isn’t in the list, it is possible to input arbitrary Unicode characters by pressing <kbd>ESC</kbd> \[number of the character (hexadecimal)\] <kbd>ESC</kbd>. Additionally the "symbols" sidebar has a right-click menu that allow to display a list of all available Unicode symbols one can add to this toolbar or to the worksheet.
fr: Si un symbole spécial ne figure pas dans la liste, il est possible de saisir des caractères Unicode arbitraires en appuyant sur <kbd>ÉCHAP</kbd> \[numéro du caractère (en hexadécimal)\] <kbd>ÉCHAP</kbd>. De plus, la barre latérale « Symboles » dispose d’un menu accessible par un clic droit, qui permet d’afficher une liste de tous les symboles Unicode disponibles que l’on peut ajouter à cette barre d’outils ou insérer dans le notebook.

note: type: Plain text
en: <kbd>ESC</kbd><kbd>6</kbd><kbd>1</kbd><kbd>ESC</kbd> therefore results in an `a`.
fr: <kbd>ESC</kbd><kbd>6</kbd><kbd>1</kbd><kbd>ESC</kbd>  est une séquence qui produit un `a`.

note: type: Plain text
en: Please note that most of these symbols (notable exceptions are the logic symbols) do not have a special meaning in _Maxima_ and therefore will be interpreted as ordinary characters. If _Maxima_ is compiled using a Lisp that doesn’t support Unicode characters they might cause an error message.
fr: Veuillez noter que la plupart de ces symboles (à l'exception notable des symboles logiques) n'ont pas de signification particulière dans _Maxima_ et seront donc interprétés comme des caractères ordinaires. Si _Maxima_ est compilé avec un Lisp qui ne supporte pas les caractères Unicode, ceux-ci peuvent provoquer un message d'erreur.

note: type: Plain text
en: It may be the case that e.g. Greek characters or mathematical symbols are not included in the selected font, then they can not be displayed.  To solve that problem, select other fonts (using: Edit -> Configure -> Style).
fr: Il est possible que, par exemple, les caractères grecs ou les symboles mathématiques ne soient pas inclus dans la police sélectionnée et ne puissent donc pas s'afficher. Pour résoudre ce problème, choisissez une autre police (via : Édition -> Configurer -> Style).

note: type: Plain text
en: ### Unicode replacement
fr: ### Remplacement de caractères Unicode

note: type: Plain text
en: wxMaxima will replace several Unicode characters with their respective Maxima expressions, e.g. `²` with `^2`, `³` with `^3`, the square root sign with the function `sqrt()`, the (mathematical) Sigma sign (which is not the same Unicode character as the corresponding Greek letter) with `sum()`, etc.
fr: wxMaxima remplacera plusieurs caractères Unicode par leurs expressions Maxima correspondantes, par exemple « ² » par « ^2 », « ³ » par « ^3 », le symbole de la racine carrée par la fonction `sqrt()`, le symbole Sigma mathématique (qui n’est pas le même caractère Unicode que la lettre grecque correspondante) par `sum()`, etc.

note: type: Plain text
en: ### Side Panes
fr: ### Les panneaux latéraux

note: type: Plain text
en: Shortcuts to the most important _Maxima_ commands, things like a table of contents, windows with debug messages or a history of the last issued commands can be accessed using the side panes. They can be enabled using the "View" menu. They all can be moved to other locations inside or outside the _wxMaxima_ window. Other useful panes is the one that allows to input Greek letters using the mouse.
fr: Les raccourcis vers les commandes les plus importantes de _Maxima_, comme une table des matières, des fenêtres avec des messages de débogage ou un historique des dernières commandes exécutées, peuvent être accessibles via les panneaux latéraux. Ceux-ci peuvent être activés depuis le menu « Affichage ». Ils peuvent tous être déplacés vers d’autres emplacements, à l’intérieur ou à l’extérieur de la fenêtre de _wxMaxima_. Un autre volet utile est celui qui permet de saisir des lettres grecques avec la souris.

note: type: Plain text
en: ![Example of different side panes](./SidePanes.png){ id=img_SidePanes }
fr: ![Illustration de différents volets latéraux](./SidePanes.png){ id=img_SidePanes }

note: type: Plain text
en: In the "table of contents" side pane, one can increase or decrease a heading by just clicking on the heading with the right mouse button and select the next higher or lower heading type.
fr: Dans le volet latéral « table des matières », vous pouvez augmenter ou diminuer le niveau d’un titre en cliquant simplement dessus avec le bouton droit de la souris et en sélectionnant le niveau de titre supérieur ou inférieur.

note: type: Plain text
en: ![Increase or decrease headings in the TOC side pane](./Sidepane-TOC-convert-headings.png){ id=Sidepane-TOC-convert-headings }
fr: ![Augmenter ou diminuer le niveau de titres dans le panneau latéral Table des Matières](./Sidepane-TOC-convert-headings.png){ id=Sidepane-TOC-convert-headings }

note: type: Plain text
en: ### MathML output
fr: ### Export MathML

note: type: Plain text
en: Several word processors and similar programs either recognize [MathML](https://www.w3.org/Math/) input and automatically insert it as an editable 2D equation - or (like LibreOffice) have an equation editor that offers an “import MathML from clipboard” feature. Others support RTF maths. _WxMaxima_, therefore, offers several entries in the right-click menu.
fr: Plusieurs logiciels de traitement de texte et programmes similaires reconnaissent soit  une entrée  [MathML](https://www.w3.org/Math/)  et l'insère automatiquement sous forme d'équation 2D modifiable, soit (comme LibreOffice) disposent d'un éditeur d'équations proposant une fonction « Importer du MathML depuis le presse-papiers ». D'autres prennent en charge les équations en RTF. _WxMaxima_ offre donc plusieurs options dans le menu contextuel (clic droit).

note: type: Plain text
en: ### Markdown support
fr: ### Prise en charge de Markdown

note: type: Plain text
en: _WxMaxima_ offers a set of standard [Markdown](https://en.wikipedia.org/wiki/Markdown) conventions that don’t collide with mathematical notation. One of these elements is bullet lists.
fr: _WxMaxima_ propose un ensemble de balises [Markdown](https://en.wikipedia.org/wiki/Markdown) standard qui n’entrent pas en conflit avec la notation mathématique. L’un de ces éléments est les listes à puces.

note: type: Plain text
en: ```
    Ordinary text
     * One item, indentation level 1
     * Another item at indentation level 1
       * An item at a second indentation level
       * A second item at the second indentation level
     * A third item at the first indentation level
    Ordinary text
    ```
fr: ```
    Texte ordinaire
    * Un élément, niveau d'indentation 1
    * Un autre élément au niveau d'indentation 1
      * Un élément au deuxième niveau d'indentation
      * Un deuxième élément au deuxième niveau d'indentation
    * Un troisième élément au premier niveau d'indentation
    Texte ordinaire
    ```

note: type: Plain text
en: _WxMaxima_ will recognize text starting with `>` chars as block quotes:
fr: _WxMaxima_ reconnaîtra le texte commençant par le caractère `>` comme des blocs de citations  :

note: type: Plain text
en: ``` Ordinary text > quote quote quote quote > quote quote quote quote > quote quote quote quote Ordinary text ```
fr: ``` Texte ordinaire > citation citation citation citation > citation citation citation citation > citation citation citation citation Texte ordinaire```

note: type: Plain text
en: _WxMaxima_’s TeX and HTML output will also recognize `=>` and replace it by the corresponding Unicode sign:
fr: _WxMaxima_ reconnaîtra `=>` dans ses sorties TeX et HTML et le remplacera par le symbole Unicode correspondant :

note: type: Plain text
en: Other symbols the HTML and TeX export will recognize are `<=` and `>=` for comparisons, a double-pointed double arrow (`<=>`), single-headed arrows (`<->`, `->` and `<-`) and `+/-` as the respective sign. For TeX output also `<<` and `>>` are recognized.
fr: D’autres symboles reconnus par les exports HTML et TeX sont `<=` et `>=` pour les comparaisons, une double flèche à double pointe (`<=>`), des flèches à une seule direction (`<->`, `->` et `<-`) ainsi que `+/-` pour le symbole correspondant. Pour la sortie TeX, les symboles `<<` et `>>` sont également reconnus.

note: type: Plain text
en: ### Hotkeys
fr: ### Raccourcis clavier

note: type: Plain text
en: Most hotkeys can be found in the text of the respective menus. Since they are actually taken from the menu text and thus can be customized by the translations of _wxMaxima_ to match the needs of users of the local keyboard, we do not document them here. A few hotkeys or hotkey aliases, though, are not documented in the menus:
fr: La plupart des raccourcis clavier peuvent être trouvés dans le texte des menus associés. Comme ils sont effectivement tirés du texte des menus, ils peuvent ainsi être personnalisés par les traductions de _wxMaxima_ pour correspondre aux besoins des utilisateurs des claviers locaux, nous ne les documentons pas ici. Cependant, quelques raccourcis clavier ou alias de raccourcis ne sont pas documentés dans les menus :

note: type: Plain text
en: ### Raw TeX in the TeX export
fr: ### TeX brut dans l'export TeX

note: type: Plain text
en: If a text cell begins with `TeX:` the TeX export contains the literal text that follows the `TeX:` marker. Using this feature allows the entry of TeX markup within the _wxMaxima_ workbook.
fr: Si une cellule de texte commence par `TeX:`, l'export TeX inclut le texte littéral qui suit le marqueur `TeX:`. Cette fonctionnalité permet d'insérer du code TeX directement dans le classeur _wxMaxima_.

note: type: Plain text
en: ## File Formats
fr: ## Formats de fichiers

note: type: Plain text
en: The material that is developed in a _wxMaxima_ session can be stored for later use in any of three ways:
fr: Le contenu développé lors d'une session _wxMaxima_ peut être enregistré pour une utilisation ultérieure de trois manières différentes :

note: type: Plain text
en: `.mac` files are ordinary text files that contain _Maxima_ commands. They can be read using _Maxima_’s `batch()` or `load()` command or _wxMaxima_’s File/Batch File menu entry.
fr: Les fichiers `.mac` sont des fichiers texte ordinaires qui contiennent des commandes _Maxima_. Ils peuvent être lus à l'aide de la commande `batch()` ou `load()` de _Maxima_, ou via l'entrée de menu Fichier/Charger un packetage de _wxMaxima_.

note: type: Plain text
en: One example is shown below. `Quadratic.mac` defines a function and afterward generates a plot with `wxdraw2d()`.  Afterward the contents of the file `Quadratic.mac` are printed and newly defined function `f()` is evaluated.
fr: Un exemple est présenté ci-dessous. `Quadratic.mac` définit une fonction, puis génère un tracé avec `wxdraw2d()`. Ensuite, le contenu du fichier `Quadratic.mac` est affiché et la fonction nouvellement définie `f()` est évaluée.

note: type: Plain text
en: ![Loading a file with `batch()`](./BatchImage.png){ id=img_BatchImage }
fr: ![Chargement d'un fichier avec `batch()`](./BatchImage.png){ id=img_BatchImage }

note: type: Plain text
en: Attention: Although the file `Quadratic.mac` has a usual _Maxima_ extension (`.mac`), it can only be read by _wxMaxima_, since the command `wxdraw2d()` is a wxMaxima-extension to _Maxima_. (Command line) Maxima will ignore the unknown command `wxdraw2d()` and print it as output again.
fr: Attention : Bien que le fichier `Quadratic.mac` ait l'extension habituelle de _Maxima_ (`.mac`), il ne peut être lu que par _wxMaxima_, car la commande `wxdraw2d()` est une extension de wxMaxima à _Maxima_. _Maxima_ en ligne de commande ignorera la commande inconnue `wxdraw2d()` et l'affichera à l'identique en sortie.

note: type: Plain text
en: You can be use `.mac` files for writing your own library of macros. But since they don’t contain enough structural information they cannot be read back as a _wxMaxima_ session.
fr: Vous pouvez utiliser les fichiers `.mac` pour écrire votre propre bibliothèque de macros. Cependant, comme ils ne contiennent pas assez d’informations structurelles, ils ne peuvent pas être relus en tant que session _wxMaxima_.

note: type: Plain text
en: #### File format of wxm files
fr: #### Format de fichier des fichiers wxm

note: type: Plain text
en: This is just a plain text file (you can open it with a text editor), containing the cell contents as some special Maxima comments.
fr: Il s'agit simplement d'un fichier texte brut (vous pouvez l'ouvrir avec un éditeur de texte), contenant le contenu des cellules sous forme de commentaires spéciaux Maxima.

note: type: Plain text
en: It starts with the following comment:
fr: Cela commence par le commentaire suivant :

note: type: Plain text
en: And then the cells follow, encoded as Maxima comments, e.g. a section cell:
fr: Puis les cellules suivent, encodées sous forme de commentaires Maxima, par exemple une cellule de section :

note: type: Plain text
en: ```
    /* [wxMaxima: section start ]
    Title of the section
       [wxMaxima: section end   ] */
    ```
fr: ```
    /* [wxMaxima: section start ]
    Titre de la section
       [wxMaxima: section end   ] */
    ```

note: type: Plain text
en: or (in a Math cell the input is of course *not* commented out (the output is not saved in a `wxm` file)):
fr: ou (dans une cellule Math, l'entrée n'est bien sûr *pas* mise en commentaire (la sortie n'est pas enregistrée dans un fichier `wxm`)) :

note: type: Plain text
en: Images are [Base64 encoded](https://en.wikipedia.org/wiki/Base64) with the image type as first line):
fr: Les images sont [encodées en Base64](https://en.wikipedia.org/wiki/Base64) avec l'indication du type de l'image sur la première ligne):

note: type: Plain text
en: ```
    /* [wxMaxima: image   start ]
    jpg
    [very chaotic looking character sequence]
       [wxMaxima: image   end   ] */
    ```
fr: ```
    /* [wxMaxima: image   start ]
    jpg
    [séquence de caractères très chaotique à première vue]
       [wxMaxima: image   end   ] */
    ```

note: type: Plain text
en: A page break is just one line containing:
fr: Une saut de page est simplement une ligne contenant :

note: type: Plain text
en: And folded cells marked by:
fr: Et les cellules repliées sont marquées par :

note: type: Plain text
en: This XML-based file format saves the complete worksheet including things like the zoom factor and the watchlist. It is the preferred file format.
fr: Ce format de fichier basé sur le XML enregistre la feuille de travail complète, y compris des éléments comme le facteur de zoom et la liste de suivi du notebook. C'est le format de fichier recommandé.

note: type: Plain text
en: #### File format of wxmx files
fr: #### Format de fichier des fichiers wxmx

note: type: Plain text
en: A `wxmx`-file seems to be a binary format, but one can handle it with tools, which are included in your OS. It is a zip file, one can decompress it with `unzip` (maybe rename it before, so that is recognized by the unzip program of your OS).  We do not use the compression function, just the possibility to merge several files into one file - images are already compressed and the rest is simple text (probably much smaller, than huge images, which are included).
fr: Un fichier `wxmx` semble être un format binaire, mais on peut le gérer avec des outils inclus dans votre système d'exploitation. Il s'agit d'un fichier zip, que l'on peut décompresser avec `unzip` (peut-être faut-il le renommer au préalable pour qu'il soit reconnu par le programme de décompression de votre OS). Nous n'utilisons pas la fonction de compression, seulement la possibilité de regrouper plusieurs fichiers en un seul — les images sont déjà compressées et le reste est du texte simple (probablement bien plus petit que les images volumineuses qu'il contient).

note: type: Plain text
en: It does contain the following files:
fr: Il contient les fichiers suivants :

note: type: Plain text
en: So, if something goes wrong, you can unzip a wxMaxima document (maybe rename it before to a `zip`-file), maybe make changes in the `content.xml` file with a text editor, or replace an broken image, zip the files again, probably rename the `zip` to a `wxmx`-file - and you get another modified `wxmx`-file.
fr: Donc, si quelque chose ne va pas, vous pouvez décompresser un document wxMaxima (peut-être en le renommant au préalable en `.zip`), éventuellement modifier le fichier `content.xml` avec un éditeur de texte ou remplacer une image corrompue, recompresser les fichiers, probablement renommer le `.zip` en `.wxmx` — et vous obtiendrez un autre fichier `wxmx` modifié.

note: type: Plain text
en: ## Configuration options
fr: ## Options pour la configuration

note: type: Plain text
en: For some common configuration variables _wxMaxima_ offers two ways of configuring:
fr: Pour certaines variables courantes liées à la configuration, _wxMaxima_ propose deux méthodes de configuration :

note: type: Plain text
en: ![wxMaxima configuration 1](./wxMaxima_configuration_001.png){ id=img_wxMaxima_configuration_001 }
fr: ![configuration 1 de wxMaxima](./wxMaxima_configuration_001.png){ id=img_wxMaxima_configuration_001 }

note: type: Plain text
en: ### Default animation framerate
fr: ### Fréquence par défaut des images pour les animations

note: type: Plain text
en: The animation framerate that is used for new animations is kept in the variable `wxanimate_framerate`. The initial value this variable will contain in a new worksheet can be changed using the configuration dialogue.
fr: La fréquence des images utilisée pour les nouvelles animations est stockée dans la variable `wxanimate_framerate`. La valeur initiale de cette variable dans un nouveau notebook peut être modifiée via la boîte de dialogue de configuration.

note: type: Plain text
en: ### Default plot size for new _maxima_ sessions
fr: ### Dimensions par défaut des graphiques pour les nouvelles sessions de _maxima_

note: type: Plain text
en: After the next start, plots embedded into the worksheet will be created with this size if the value of `wxplot_size` isn’t changed by _maxima_.
fr: Lors du prochain démarrage, les graphiques intégrés au notebook seront créés avec ces dimensions, sauf si la valeur de `wxplot_size` est modifiée par _Maxima_.

note: type: Plain text
en: In order to set the plot size of a single graph only use the following notation can be used that sets a variable’s value for one command only:
fr: Afin de définir la taille d'un seul graphique, la notation suivante peut être utilisée afin d'affecter une valeur à une variable pour une seule commande :

note: type: Plain text
en: ### Match parenthesis in text controls
fr: ### Correspondance des parenthèses dans les zones de texte

note: type: Plain text
en: This option enables two things:
fr: Cette option active deux fonctionnalités :

note: type: Plain text
en: ### Don’t save the worksheet automatically
fr: ### Ne pas enregistrer automatiquement le notebook

note: type: Plain text
en: If this option is set, the file where the worksheet is will be overwritten only the request of the user. In case of a crash/power loss/... a recent backup copy is still made available in the temp directory, though.
fr: Si cette option est activée, le fichier du notebook ne sera écrasé que sur demande de l'utilisateur. En cas de plantage, de coupure de courant ou autre incident, une copie de sauvegarde récente reste cependant disponible dans le dossier temporaire.

note: type: Plain text
en: If this option isn’t set _wxMaxima_ behaves more like a modern cellphone app:
fr: Si cette option n'est pas activée, _wxMaxima_ se comporte davantage comme une application moderne de smartphone :

note: type: Plain text
en: ### Where is the configuration saved?
fr: ### Où est enregistrée la configuration  ?

note: type: Plain text
en: If you are using Unix/Linux, the configuration information will be saved in a file `.wxMaxima` in your home directory (if you are using wxWidgets \< 3.1.1), or `.config/wxMaxima.conf` ((XDG-Standard) if wxWidgets >= 3.1.1 is used). You can retrieve the wxWidgets version from the command `wxbuild_info();` or by using the menu option Help->About. [wxWidgets](https://www.wxwidgets.org/) is the cross-platform GUI library, which is the base for _wxMaxima_ (therefore the `wx` in the name).  (Since the filename starts with a dot, `.wxMaxima` or `.config` will be hidden).
fr: Si vous utilisez Unix/Linux, les informations de configuration sont enregistrées dans un fichier `.wxMaxima` de votre répertoire personnel (si vous utilisez wxWidgets < 3.1.1), ou dans `.config/wxMaxima.conf` (norme XDG, si wxWidgets >= 3.1.1 est utilisé). Vous pouvez connaître la version de wxWidgets avec la commande `wxbuild_info();` ou via le menu Aide → À propos. [wxWidgets](https://www.wxwidgets.org/) est la bibliothèque d'interface graphique multiplateforme sur laquelle repose _wxMaxima_ (d'où le `wx` dans le nom). (Ces fichiers ou dossiers, commençant par un point, `.wxMaxima` ou `.config`, sont donc des fichiers cachés).

note: type: Plain text
en: If you are using Windows, the configuration will be stored in the registry. You will find the entries for _wxMaxima_ at the following position in the registry: `HKEY_CURRENT_USER\Software\wxMaxima`
fr: Si vous utilisez Windows, la configuration est stockée dans le registre. Vous trouverez les entrées pour _wxMaxima_ à l'emplacement suivant du registre : `HKEY_CURRENT_USER\Software\wxMaxima`

note: type: Plain text
en: # Extensions to _Maxima_
fr: # Extensions pour _Maxima_

note: type: Plain text
en: _WxMaxima_ is primarily a graphical user interface for _Maxima_. As such, its main purpose is to pass along commands to _Maxima_ and to report the results of executing those commands. In some cases, however, _wxMaxima_ adds functionality to _Maxima_. _WxMaxima_’s ability to generate reports by exporting a workbook’s contents to HTML and LaTeX files has been mentioned. This section considers some ways that _wxMaxima_ enhances the inclusion of graphics in a session.
fr: _WxMaxima_ est avant tout une interface graphique pour _Maxima_. Ainsi, son rôle principal consiste à transmettre les commandes à _Maxima_ et à afficher les résultats de leur exécution. Cependant, _WxMaxima_ ajoute également certaines fonctionnalités à _Maxima_. La capacité de _WxMaxima_ à générer des rapports en exportant le contenu d'un notebook vers des fichiers HTML et LaTeX a déjà été évoquée. Cette section aborde certaines améliorations apportées par _WxMaxima_ pour l'inclusion de graphiques dans une session.

note: type: Plain text
en: ## Subscripted variables
fr: ## Variables en indice

note: type: Plain text
en: `wxsubscripts` specifies, if (and how) _wxMaxima_ will autosubscript variable names:
fr: `wxsubscripts` définit si (et comment) _wxMaxima appliquera automatiquement des indices aux noms de variables :

note: type: Plain text
en: If it is `false`, the functionality is off, wxMaxima will not autosubscript part of variable names after an underscore.
fr: Si sa valeur est `false`, cette fonctionnalité est désactivée : wxMaxima ne transformera pas automatiquement en indices les parties des noms de variables suivant un tiret bas.

note: type: Plain text
en: If it is set to `'all`, everything after an underscore will be subscripted.
fr: Si elle est définie sur `'all`, tout ce qui suit un tiret bas sera converti en indice.

note: type: Plain text
en: If it is set to `true` variable names of the format `x_y` are displayed using a subscript if
fr: Si elle est définie sur `true`, les noms de variables au format `x_y` s'affichent avec un indice uniquement si

note: type: Plain text
en: ![How variables are autosubscripted using wxsubscripts](./wxsubscripts.png){ id=img_wxsubscripts }
fr: ![Comment les variables sont automatiquement mises en indices en utilisant wxsubscripts](./wxsubscripts.png){ id=img_wxsubscripts }

note: type: Plain text
en: If the variable name doesn’t match these requirements, it can still be declared as "to be subscripted" using the command `wxdeclare_subscript(variable_name);` or `wxdeclare_subscript([variable_name1,variable_name2,...]);` Declaring a variable as subscripted can be reverted using the following command: `wxdeclare_subscript(variable_name,false);`
fr: Si le nom de la variable ne répond pas à ces exigences, il peut toujours être déclaré comme « à mettre en indice » en utilisant la commande `wxdeclare_subscript(nom_variable);` ou `wxdeclare_subscript([nom_variable1, nom_variable2, ...]);`Une déclaration de variable en tant qu’indice peut être annulée avec la commande suivante : `wxdeclare_subscript(nom_variable, false);`

note: type: Plain text
en: You can use the menu "View->Autosubscript" to set these values.
fr: Vous pouvez utiliser le menu "Affichage->Mise en indice automatique" pour définir ces valeurs.

note: type: Plain text
en: ## User feedback in the status bar
fr: ## Message utilisateur dans la barre d'état

note: type: Plain text
en: Long-running commands can provide user feedback in the status bar. This user feedback is replaced by any new feedback that is placed there (allowing to use it as a progress indicator) and is deleted as soon as the current command sent to _Maxima_ is finished. It is safe to use `wxstatusbar()` even in libraries that might be used with plain _Maxima_ (as opposed to _wxMaxima_): If _wxMaxima_ isn’t present the `wxstatusbar()` command will just be left unevaluated.
fr: Les commandes qui durent longtemps peuvent générer un message pour l'utilisateur dans la barre d'état. Ce dernier est remplacé par tout nouveau message qui apparait dans cette barre (ce qui permet de l'utiliser comme indicateur de progression) et est supprimé dès que la commande actuelle envoyée à _Maxima_ est terminée. Il n'y a pas de risque à utiliser `wxstatusbar()` même avec des bibliothèques qui pourraient être utilisées avec _Maxima_ standard (par opposition à _wxMaxima_) : si _wxMaxima_ n'est pas présent, la commande `wxstatusbar()` restera simplement non évaluée.

note: type: Plain text
en: ```maxima
    for i:1 thru 10 do (
        /* Tell the user how far we got */
        wxstatusbar(concat("Pass ",i)),
        /* (sleep n) is a Lisp function, which can be used */
        /* with the character "?" before. It delays the */
        /* program execution (here: for 3 seconds) */
        ?sleep(3)
    )$
    ```
fr: ```maxima
    for i:1 thru 10 do (
        /* Informe l'utilisateur de l'avancement. */
        wxstatusbar(concat("Pass ",i)),
        /* (sleep n) est une fonction Lisp, qui peut être utilisée */
        /* avec le caractère "?" avant. Cela retarde */
        /* l'exécution du programme (dans ce cas : pour 3 secondes) */
        ?sleep(3)
    )$
    ```

note: type: Plain text
en: ## Plotting
fr: ## Graphiques

note: type: Plain text
en: Plotting (having fundamentally to do with graphics) is a place where a graphical user interface will have to provide some extensions to the original program.
fr: La création de courbes (qui repose fondamentalement sur des éléments graphiques) est un domaine où une interface utilisateur graphique devra apporter certaines extensions au programme d'origine.

note: type: Plain text
en: ### Embedding a plot into the worksheet
fr: ### Intégrer un graphique dans le notebook

note: type: Plain text
en: _Maxima_ normally instructs the external program _Gnuplot_ to open a separate window for every diagram it creates. Since many times it is convenient to embed graphs into the worksheet instead _wxMaxima_ provides its own set of plot functions that don’t differ from the corresponding _maxima_ functions save in their name: They are all prefixed by a “wx”.
fr: Normalement, _Maxima_ demande au programme externe _Gnuplot_ d'ouvrir une fenêtre séparée pour chaque graphique qu'il génère. Comme il est souvent plus pratique d'intégrer les graphiques directement dans le notebook, _wxMaxima_ propose son propre ensemble de fonctions graphiques. Celles-ci ne diffèrent des fonctions _Maxima_ correspondantes que par leur nom : elles sont toutes préfixées par « wx ».

note: type: Plain text
en: The following plotting functions have wx-counterparts:
fr: Les fonctions graphiques suivantes ont leurs équivalents préfixés par « wx » :

note: type: Plain text
en: | wxMaxima’s plot function | Maxima’s plot function                                                                          |
    | ------------------------ | ----------------------------------------------------------------------------------------------- |
    | `wxplot2d()`             | [plot2d](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#plot2d)               |
    | `wxplot3d()`             | [plot3d](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#plot3d)               |
    | `wxdraw2d()`             | [draw2d](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#draw2d)               |
    | `wxdraw3d()`             | [draw2d](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#draw3d)               |
    | `wxdraw()`               | [draw](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#draw)                   |
    | `wximplicit_plot()`      | [implicit_plot](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#implicit_plot) |
    | `wxhistogram()`          | [histogram](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#histogram)         |
    | `wxscatterplot()`        | [scatterplot](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#scatterplot)     |
    | `wxbarsplot()`           | [barsplot](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#barsplot)           |
    | `wxpiechart()`           | [piechart](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#piechart)           |
    | `wxboxplot()`            | [boxplot](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#boxplot)             |
fr: | wxMaximaâ fonction graphique | Maxima fonction graphique                                                                          |
    | ------------------------ | ----------------------------------------------------------------------------------------------- |
    | `wxplot2d()`             | [plot2d](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#plot2d)               |
    | `wxplot3d()`             | [plot3d](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#plot3d)               |
    | `wxdraw2d()`             | [draw2d](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#draw2d)               |
    | `wxdraw3d()`             | [draw2d](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#draw3d)               |
    | `wxdraw()`               | [draw](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#draw)                   |
    | `wximplicit_plot()`      | [implicit_plot](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#implicit_plot) |
    | `wxhistogram()`          | [histogram](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#histogram)         |
    | `wxscatterplot()`        | [scatterplot](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#scatterplot)     |
    | `wxbarsplot()`           | [barsplot](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#barsplot)           |
    | `wxpiechart()`           | [piechart](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#piechart)           |
    | `wxboxplot()`            | [boxplot](https://maxima.sourceforge.io/docs/manual/maxima_singlepage.html#boxplot)             |

note: type: Plain text
en: If a `wxm`-file is read by (console) Maxima, these functions are ignored (and printed as output, as other unknown functions in Maxima).
fr: Si un fichier `.wxm` est lu par _Maxima_ (en mode console), ces fonctions sont ignorées (et affichées à l'identique en sortie, comme toute autre fonction inconnue dans _Maxima_).

note: type: Plain text
en: ### Making embedded plots bigger or smaller
fr: ### Agrandir ou diminuer les graphiques intégrés

note: type: Plain text
en: As noted above, the configure dialog provides a way to change the default size plots created which sets the starting value of `wxplot_size`. The plotting routines of _wxMaxima_ respect this variable that specifies the size of a plot in pixels. It can always be queried or used to set the size of the following plots:
fr: Comme indiqué précédemment, la boîte de dialogue de configuration permet de modifier la taille par défaut des graphiques créés, en définissant la valeur initiale de `wxplot_size`. Les routines graphiques de _wxMaxima_ tiennent compte de cette variable, qui spécifie la taille d'un graphique en pixels. Il est toujours possible d'interroger ou de définir cette variable pour ajuster la taille des graphiques suivants :

note: type: Plain text
en: If the size of only one plot is to be changed _Maxima_ provides a canonical way to change an attribute only for the current cell. In this usage the specification `wxplot_size = [value1, value2]` is appended to the `wxdraw2d( )` command, and is not part of the `wxdraw2d` command.
fr: Si la dimension d'un seul graphique doit être modifiée, _Maxima_ offre une méthode standard pour changer l'attribut de taille uniquement pour la cellule actuelle. Dans ce cas, la spécification `wxplot_size = [valeur1, valeur2]` est ajoutée à la commande `wxdraw2d()`, sans faire partie intégrante de cette commande.

note: type: Plain text
en: Setting the size of embedded plot with `wxplot_size` works for embedded plots using e.g. `wxplot`, `wxdraw`, `wxcontour_plot` and `wximplicit_plot` commands and for embedded animations with `with_slider_draw` and `wxanimate` commands.
fr: Le réglage de la taille des graphiques intégrés avec `wxplot_size` fonctionne pour les graphiques en ligne utilisant par exemple les commandes `wxplot`, `wxdraw`, `wxcontour_plot` et `wximplicit_plot`, ainsi que pour les animations intégrées avec les commandes `with_slider_draw` et `wxanimate`.

note: type: Plain text
en: ### Better quality plots
fr: ### Des graphiques de meilleur qualité

note: type: Plain text
en: _Gnuplot_ doesn’t seem to provide a portable way of determining whether it supports the high-quality bitmap output that the Cairo library provides. On systems where _Gnuplot_ is compiled to use this library the pngCairo option from the configuration menu (that can be overridden by the variable `wxplot_pngcairo`) enables support for antialiasing and additional line styles. If `wxplot_pngCairo` is set without _Gnuplot_ supporting this the result will be error messages instead of graphics.
fr: Il semble que _Gnuplot_ ne propose pas de méthode portable pour déterminer s'il prend en charge la sortie bitmap haute qualité fournie par la bibliothèque Cairo. Sur les systèmes où _Gnuplot_ est compilé pour utiliser cette bibliothèque, l'option pngCairo du menu de configuration (qui peut être écrasée par la variable `wxplot_pngcairo`) active la prise en charge de l'antialiasing et des styles de ligne supplémentaires. Si `wxplot_pngcairo` est définie alors que _Gnuplot_ ne supporte pas cette fonctionnalité, le résultat résultera en des messages d'erreur au lieu des graphiques.

note: type: Plain text
en: ### Opening embedded plots in interactive _Gnuplot_ windows
fr: ### Ouvrir les graphiques intégrés dans les fenêtres interactives de _Gnuplot_

note: type: Plain text
en: If a plot was generated using the `wxdraw`-type commands (`wxplot2d` and `wxplot3d` isn’t supported by this feature) and the file size of the underlying _Gnuplot_ project isn’t way too high _wxMaxima_ offers a right-click menu that allows to open the plot in an interactive _Gnuplot_ window.
fr: Si un graphique a été généré avec des commandes de type `wxdraw` (`wxplot2d` et `wxplot3d` ne sont pas pris en charge par cette fonctionnalité) et que la taille du fichier du projet _Gnuplot_ correspondant n'est pas trop élevée, _wxMaxima_ propose un menu contextuel (clic droit) permettant d'ouvrir le graphique dans une fenêtre interactive _Gnuplot_.

note: type: Plain text
en: ### Opening Gnuplot’s command console in `plot` windows
fr: ### Ouvrir la console de commandes de Gnuplot dans les fenêtres `plot`

note: type: Plain text
en: On MS Windows, there are two Gnuplot programs, `gnuplot.exe` and `wgnuplot.exe`.  You can configure, which command should be used using the configuration menu. `wgnuplot.exe` offers the possibility to open a console window, where _gnuplot_ commands can be entered into, `gnuplot.exe` does not offer this possibility. Unfortunately, `wgnuplot.exe` causes _Gnuplot_ to "steal" the keyboard focus for a short time every time a plot is prepared.
fr: Sous MS Windows, il existe deux programmes Gnuplot : `gnuplot.exe` et `wgnuplot.exe`. Vous pouvez configurer lequel utiliser via le menu de configuration. `wgnuplot.exe` permet d'ouvrir une fenêtre de console où les commandes _Gnuplot_ peuvent être saisies, ce que `gnuplot.exe` ne propose pas. Malheureusement, `wgnuplot.exe` provoque un bref "décrochage" du focus clavier à chaque génération d'un graphique.

note: type: Plain text
en: ### Embedding animations into the spreadsheet
fr: ### Intégrer des animations dans le notebook

note: type: Plain text
en: 3D diagrams tend to make it hard to read quantitative data. A viable alternative might be to assign the 3rd parameter to the mouse wheel. The `with_slider_draw` command is a version of `wxdraw2d` that does prepare multiple plots and allows to switch between them by moving the slider on top of the screen. _WxMaxima_ allows to export this animation as an animated gif.
fr: Les diagrammes en 3D impliquent souvent que la lecture des données quantitatives soit difficile. Une alternative intéressante consiste à associer le 3ᵉ paramètre à la molette de la souris. La commande `with_slider_draw` est une version de `wxdraw2d` qui génère plusieurs graphiques et permet de basculer entre eux à l'aide d'un curseur situé en haut de l'écran. _WxMaxima_ permet d'exporter cette animation au format GIF animé.

note: type: Plain text
en: The first two arguments for `with_slider_draw` are the name of the variable that is stepped between the plots and a list of the values of these variable. The arguments that follow are the ordinary arguments for `wxdraw2d`:
fr: Les deux premiers arguments de `with_slider_draw` sont le nom du paramètre qui varie entre les graphiques et une liste des valeurs prises par ce paramètre. Les arguments suivants sont les arguments classiques de la commande `wxdraw2d` :

note: type: Plain text
en: The same functionality for 3D plots is accessible as `with_slider_draw3d`, which allows for rotating 3d plots:
fr: La même fonctionnalité pour les graphiques 3D est accessible avec `with_slider_draw3d`, qui permet de faire tourner les graphiques 3D :

note: type: Plain text
en: If the general shape of the plot is what matters it might suffice to move the plot just a little bit in order to make its 3D nature available to the intuition:
fr: Si c'est plutôt la forme générale du graphique qui importe, un léger déplacement peut suffire pour rendre la visualisation 3D plus intuitive :

note: type: Plain text
en: For those more familiar with `plot` than with `draw`, there is a second set of functions:
fr: Pour ceux qui maîtrisent mieux la commande `plot` que `draw`, il existe un second ensemble de fonctions :

note: type: Plain text
en: Normally the animations are played back or exported with the frame rate chosen in the configuration of _wxMaxima_. To set the speed at an individual animation is played back the variable `wxanimate_framerate` can be used:
fr: Normalement, les animations sont lues ou exportées avec le taux de rafraîchissement défini dans la configuration de _wxMaxima_. Pour régler la vitesse de lecture d'une animation donnée, on peut utiliser la variable `wxanimate_framerate` :

note: type: Plain text
en: The animation functions use _Maxima_’s `makelist` command and therefore share the pitfall that the slider variable’s value is substituted into the expression only if the variable is directly visible in the expression. Therefore the following example will fail:
fr: Les fonctions d'animation utilisent la commande `makelist` de _Maxima_ et partagent donc le même écueil : la valeur de la variable du curseur n'est substituée dans l'expression que si cette variable y apparaît explicitement. Par conséquent, l'exemple suivant échouera :

note: type: Plain text
en: ```maxima
    f:sin(a*x);
    with_slider_draw(
        a,makelist(i/2,i,1,10),
        title=concat("a=",float(a)),
        grid=true,
        explicit(f,x,0,10)
    )$
    ```
fr: ``maxima
    f:sin(a*x);
    with_slider_draw(
        a,makelist(i/2,i,1,10),
        title=concat("a=",float(a)),
        grid=true,
        explicit(f,x,0,10)
    )$

note: type: Plain text
en: If _Maxima_ is explicitly asked to substitute the slider’s value plotting works fine instead:
fr: Si _Maxima_ est explicitement invité à substituer la valeur du curseur, le tracé fonctionne correctement :

note: type: Plain text
en: ### Opening multiple plots in contemporaneous windows
fr: ### Ouvrir plusieurs graphiques dans des fenêtres de manière simultanée

note: type: Plain text
en: While not being provided by _wxMaxima_ this feature of _Maxima_ (on setups that support it) sometimes comes in handily. The following example comes from a post from Mario Rodriguez to the _Maxima_ mailing list:
fr: Cette fonctionnalité de _Maxima_ (sur les configurations qui la supportent), bien qu'elle ne soit pas disponible via  _wxMaxima_, s'avère parfois bien pratique. L'exemple suivant provient d'un message de Mario Rodriguez sur la _liste de diffusion de Maxima_ :

note: type: Plain text
en: /* Parabola in window #1 */ draw2d(terminal=[wxt,1],explicit(x^2,x,-1,1));
fr: /* Une parabole dans une fenêtre #1 */ draw2d(terminal=[wxt,1],explicit(x^2,x,-1,1));

note: type: Plain text
en: /* Parabola in window #2 */ draw2d(terminal=[wxt,2],explicit(x^2,x,-1,1));
fr: /* Une parabole dans une fenêtre #2 */ draw2d(terminal=[wxt,2],explicit(x^2,x,-1,1));

note: type: Plain text
en: /* Paraboloid in window #3 */ draw3d(terminal=[wxt,3],explicit(x^2+y^2,x,-1,1,y,-1,1)); ```
fr: /* Un paraboloide dans une fenêtre #3 */ draw3d(terminal=[wxt,3],explicit(x^2+y^2,x,-1,1,y,-1,1)); ```

note: type: Plain text
en: Plotting multiple plots in the same window is possible, too (the same is possible in command line Maxima with the standard `draw()` command):
fr: Il est également possible de tracer plusieurs graphiques dans une même fenêtre (la même chose est réalisable avec la commande standard `draw()` de Maxima en ligne de commande) :

note: type: Plain text
en: ### The "Plot using draw" side pane
fr: ### Le panneau latéral "Graphiques avec draw"

note: type: Plain text
en: The "Plot using draw" sidebar hides a simple code generator that allows generating scenes that make use of some of the flexibility of the _draw_ package _maxima_ comes with.
fr: Le panneau latéral "Graphiques avec draw" cache un générateur simple de code qui permet de créer des représentations graphiques exploitant une partie des fonctionnalités du package _draw_ intégré à _Maxima_.

note: type: Plain text
en: Generates the skeleton of a `draw()` command that draws a 2D scene. This scene later has to be filled with commands that generate the scene’s contents, for example by using the buttons in the rows below the "2D" button.
fr: Génère le squelette d'une commande `draw()` pour dessiner une scène 2D. Cette scène doit ensuite être complétée avec des commandes qui génèrent son contenu, par exemple en utilisant les boutons situés dans les lignes en dessous du bouton "2D".

note: type: Plain text
en: One helpful feature of the 2D button is that it allows to set up the scene as an animation in which a variable (by default it is _t_) has a different value in each frame: Often a moving 2D plot allows easier interpretation than the same data in a non-moving 3D one.
fr: Une fonctionnalité utile du bouton 2D est qu'il permet de configurer la scène comme une animation dans laquelle un paramètre (par défaut, _t_) prend une valeur différente à chaque image : une courbe 2D animée facilite souvent l'interprétation des données plus qu'une représentation 3D statique des mêmes informations.

note: type: Plain text
en: Generates the skeleton of a `draw()` command that draws a 3D scene. If neither a 2D nor a 3D scene is set up, all of the other buttons set up a 2D scene that contains the command the button generates.
fr: Génère le squelette d'une commande `draw()` pour tracer une scène 3D. Si aucune scène 2D ou 3D n'est définie, tous les autres boutons configurent automatiquement une scène 2D contenant la commande générée par le bouton.

note: type: Plain text
en: Appends a standard plot of an expression like `sin(x)`, `x*sin(x)` or `x^2+2*x-4` to the `draw()` command the cursor currently is in. If there is no draw command a 2D scene with the plot is generated. Each scene can be filled with any number of plots.
fr: Ajoute un tracé standard d'une expression comme `sin(x)`, `x*sin(x)` ou `x^2+2*x-4` à la commande `draw()` où se trouve actuellement le curseur. Si aucune commande `draw()` n'existe, une scène 2D avec ce tracé est générée. Chaque scène peut contenir un nombre illimité de graphiques.

note: type: Plain text
en: #### Implicit plot
fr: #### Courbe définie de manière implicite

note: type: Plain text
en: Tries to find all points an expression like `y=sin(x)`, `y*sin(x)=3` or `x^2+y^2=4` is true at and plots the resulting curve in the `draw()` command the cursor currently is in. If there is no draw command a 2D scene with the plot is generated.
fr: Tente de trouver tous les points où une expression comme `y=sin(x)`, `y*sin(x)=3` ou `x^2+y^2=4` est vérifiée et trace la courbe résultante dans la commande `draw()` où se trouve le curseur. Si aucune commande `draw()` n'existe, une scène 2D avec ce tracé est générée.

note: type: Plain text
en: #### Parametric plot
fr: #### Courbe paramétrique

note: type: Plain text
en: Steps a variable from a lower limit to an upper limit and uses two expressions like `t*sin(t)` and `t*cos(t)` for generating the x, y (and in 3D plots also z) coordinates of a curve that is put into the current draw command.
fr: Fait varier une variable entre une borne inférieure et une borne supérieure, puis utilise deux expressions comme `t*sin(t)` et `t*cos(t)` pour générer les coordonnées x, y (et z dans le cas des tracés 3D) d'une courbe, qui est ensuite insérée dans la commande `draw()` actuelle.

note: type: Plain text
en: Draws many points that can optionally be joined. The coordinates of the points are taken from a list of lists, a 2D array or one list or array for each axis.
fr: Trace plusieurs points, éventuellement reliés entre eux. Les coordonnées des points peuvent provenir d'une liste de listes, d'un tableau 2D, ou d'une liste ou d'un tableau pour chaque axe.

note: type: Plain text
en: #### Diagram title
fr: #### Titre du graphique

note: type: Plain text
en: Draws a title on the upper end of the diagram,
fr: Ajoute un titre en haut du graphique,

note: type: Plain text
en: #### Axis
fr: #### Axes

note: type: Plain text
en: Sets up the axis.
fr: Configurer l'axe.

note: type: Plain text
en: #### Contour
fr: #### Lignes de niveau

note: type: Plain text
en: (Only for 3D plots): Adds contour lines similar to the ones one can find in a map of a mountain to the plot commands that follow in the current `draw()` command and/or to the ground plane of the diagram. Alternatively, this wizard allows skipping drawing the curves entirely only showing the contour plot.
fr: (Uniquement pour les tracés 3D) : Ajoute des lignes de niveau similaires à celles que l'on trouve sur une carte de montagne aux commandes du tracé qui suivent dans la commande `draw()` actuelle et/ou au plan de base du graphique. Alternativement, cet assistant permet de sauter entièrement le tracé des courbes et d'afficher uniquement le tracé des lignes de niveau.

note: type: Plain text
en: #### Plot name
fr: #### Légende du graphique

note: type: Plain text
en: Adds a legend entry showing the next plot’s name to the legend of the diagram. An empty name disables generating legend entries for the following plots.
fr: Ajoute une nouvelle entrée pour la légende affichant le nom du prochain tracé à la légende actuelle du graphique. Un nom vide désactive la génération d'entrées des légende pour les tracés suivants.

note: type: Plain text
en: #### Line colour
fr: #### Couleur de la ligne du tracé

note: type: Plain text
en: Sets the line colour for the following plots the current draw command contains.
fr: Définit la couleur de ligne pour les tracés suivants contenus dans la commande `draw()` actuelle.

note: type: Plain text
en: #### Fill colour
fr: #### Couleur de remplissage

note: type: Plain text
en: Sets the fill colour for the following plots the current draw command contains.
fr: Définit la couleur de remplissage pour les tracés suivants contenus dans la commande `draw()` actuelle.

note: type: Plain text
en: #### Grid
fr: #### Quadrillage

note: type: Plain text
en: Pops up a wizard that allows to set up grid lines.
fr: Ouvre un assistant permettant de configurer les lignes du quadrillage.

note: type: Plain text
en: #### Accuracy
fr: #### Précision

note: type: Plain text
en: Allows to select an adequate point in the speed vs. accuracy tradeoff that is part of any plot program.
fr: Permet de choisir un compromis adapté entre vitesse et précision, inhérent à tout programme de tracé graphique.

note: type: Plain text
en: ### Modify font and font size for plots
fr: ### Modifier la police et la taille de police pour les graphiques.

note: type: Plain text
en: Especially when you use a high resolution display, the default font size might be very small. For the `draw`-based commands, you can set the font / font size using options like `font=...`, `font_size=...`, e.g.:
fr: Surtout lorsque vous utilisez un affichage haute résolution, la taille de police par défaut peut être très petite. Pour les commandes basées sur `draw`, vous pouvez définir la police et la taille de police à l'aide d'options comme `font=...`, `font_size=...`, par exemple :

note: type: Plain text
en: For the `plot`-commands (e.g. `wxplot2d`, `wxplot3d`) font sizes and fonts can be set using the `gnuplot_preamble` command, e.g.:
fr: Pour les commandes de type `plot` (par exemple `wxplot2d`, `wxplot3d`), les tailles et polices de caractères peuvent être définies à l'aide de la commande `gnuplot_preamble`, par exemple :

note: type: Plain text
en: This sets the font for the numbers to Arial with size 30, the size for the xlabel and ylabel font to 20 (with the default font).
fr: Cela définit la police pour les nombres en Arial avec une taille de 30, et la taille de la police des étiquettes xlabel et ylabel à 20 (avec la police par défaut).

note: type: Plain text
en: Read the Maxima and Gnuplot documentation for further information.  Note: Gnuplot seems to have issues with larger font sizes, see [wxMaxima issue 1966](https://github.com/wxMaxima-developers/wxmaxima/issues/1966).
fr: Consultez la documentation de Maxima et Gnuplot pour plus d'informations. Remarque : Gnuplot semble rencontrer des problèmes avec les polices de grande taille, voir [wxMaxima issue 1966](https://github.com/wxMaxima-developers/wxmaxima/issues/1966).

note: type: Plain text
en: ## Embedding graphics
fr: ## Graphiques intégrés

note: type: Plain text
en: If the `.wxmx` file format is being used embedding files in a _wxMaxima_ project can be done as easily as per drag-and-drop. But sometimes (for example if an image’s contents might change later on in a session) it is better to tell the file to load the image on evaluation:
fr: Si le format de fichier `.wxmx` est utilisé, l'intégration de fichiers dans un notebook _wxMaxima_ peut se faire simplement par glisser-déposer. Mais parfois (par exemple si le contenu d'une image est susceptible de changer plus tard dans une session), il est préférable d'indiquer au fichier de charger l'image lors de l'évaluation :

note: type: Plain text
en: ## Startup files
fr: ## Fichiers au démarrage

note: type: Plain text
en: The config dialogue of _wxMaxima_ offers to edit two files with commands that are executed on startup:
fr: La boîte de dialogue de configuration de _wxMaxima_ permet de modifier deux fichiers contenant des commandes exécutées au démarrage :

note: type: Plain text
en: For example, if Gnuplot is installed in `/opt` (maybe on MacOS), you can add `gnuplot_command:"/opt/local/bin/gnuplot"$` (or `/opt/gnuplot/bin/gnuplot` or any other path) to these files.
fr: Par exemple, si Gnuplot est installé dans `/opt` (peut-être sur macOS), vous pouvez ajouter `gnuplot_command:"/opt/local/bin/gnuplot"$` (ou `/opt/gnuplot/bin/gnuplot` ou tout autre chemin) à ces fichiers.

note: type: Plain text
en: These files are in the Maxima user directory (usually `%USERPROFILE%/maxima` in Windows, `$HOME/.maxima` otherwise). The location can be found out with the command: `maxima_userdir;`
fr: Ces fichiers se trouvent dans le répertoire utilisateur de Maxima (généralement `%USERPROFILE%/maxima` sous Windows, ou `$HOME/.maxima` sinon). Vous pouvez connaître leur emplacement avec la commande : `maxima_userdir;`

note: type: Plain text
en: ## Special variables wx...
fr: ## Variables spéciales wx...

note: type: Plain text
en: ## Pretty-printing 2D output
fr: ## Affichage formaté en 2D

note: type: Plain text
en: The function `table_form()` displays a 2D list in a form that is more readable than the output from _Maxima_’s default output routine. The input is a list of one or more lists. Like the "print" command, this command displays output even when ended with a dollar sign. Ending the command with a semicolon results in the same table along with a "done" statement.
fr: La fonction `table_form()` affiche une liste 2D sous une forme plus lisible que le résultat produit par la sortie par défaut de _Maxima_. L'argument doit être une liste contenant une ou plusieurs listes. Comme la commande "print", cette commande affiche le résultat même si elle se termine par un dollar (`$`). Si elle se termine par un point-virgule (`;`), le tableau s'affiche accompagné d'un message "done".

note: type: Plain text
en: As the next example shows, the lists that are assembled by the `table_form` command can be created before the command is executed.
fr: Comme le montre l'exemple suivant, les listes utilisées par la commande `table_form` peuvent être créées avant son exécution.

note: type: Plain text
en: ![A third table example](./MatrixTableExample.png){ id=img_MatrixTableExample }
fr: ![Un troisième exemple de tableau](./MatrixTableExample.png){ id=img_MatrixTableExample }

note: type: Plain text
en: Also, because a matrix is a list of lists, matrices can be converted to tables in a similar fashion.
fr: De même, comme une matrice est une liste de listes, elle peut être convertie en tableau de manière similaire.

note: type: Plain text
en: ![Another table_form example](./SecondTableExample.png){ id=img_SecondTableExample }
fr: ![Un autre exemple avec table_form](./SecondTableExample.png){ id=img_SecondTableExample }

note: type: Plain text
en: ## Bug reporting
fr: ## Signalement de bugs

note: type: Plain text
en: _WxMaxima_ provides a few functions that gather bug reporting information about the current system:
fr: _WxMaxima_ propose quelques fonctions qui collectent des informations utiles pour signaler un bug concernant le système actuel :

note: type: Plain text
en: ## Marking output being drawn in red
fr: ## Ecrire le résultat de la sortie en rouge

note: type: Plain text
en: _Maxima_’s `box()` command causes _wxMaxima_ to print its argument with a red foreground, if the second argument to the command is the text `highlight`.
fr: La commande `box()` de _Maxima_ permet à _wxMaxima_ d'afficher son argument en rouge, si le deuxième argument de la commande est le texte `highlight`.

note: type: Plain text
en: # Help menu
fr: # Menu d'aide

note: type: Plain text
en: WxMaxima’s help menu provides access to the Maxima and wxMaxima manual, tips, some example worksheets and in command line Maxima included demos (the `demo()` command).
fr: Le menu d'aide de _wxMaxima_ donne accès au manuel de Maxima et à celui de wxMaxima, à des astuces, à des exemples de notebooks, ainsi qu'aux exemples intégrés dans Maxima en ligne de commande (via la commande `demo()`).

note: type: Plain text
en: Please notice, that the demos write:
fr: Veuillez noter que les exemples indiquent :

note: type: Plain text
en: ~~~ At the ’_’ prompt, type ’;’ and <enter> to proceed with the demonstration.  ~~~
fr: ~~~ À l’invite `’_’`, tapez `;` puis `<entrée>` pour poursuivre la démonstration.  ~~~

note: type: Plain text
en: That is valid for command-line Maxima, however in wxMaxima by default it is necessary to continue the demonstration with: <kbd>CTRL</kbd>+<kbd>ENTER</kbd>
fr: Cela est valable pour Maxima en ligne de commande, mais dans wxMaxima, par défaut, il est nécessaire de poursuivre la démonstration avec : <kbd>CTRL</kbd> + <kbd>ENTRÉE</kbd>

note: type: Plain text
en: (That can be configured in the Configure->Worksheet->"Hotkeys for sending commands to Maxima" menu.)
fr: (Ce comportement peut être configuré dans le menu Configurer → Notebook → " Raccourcis pour envoyer des commandes à Maxima".)

note: type: Plain text
en: # Troubleshooting
fr: # Résolution des problèmes

note: type: Plain text
en: ## Cannot connect to _Maxima_
fr: ## Impossible de se connecter à _Maxima_

note: type: Plain text
en: Since _Maxima_ (the program that does the actual mathematics) and _wxMaxima_ (providing the easy-to-use user interface) are separate programs that communicate by the means of a local network connection. Therefore the most probable cause is that this connection is somehow not working. For example, a firewall could be set up in a way that it doesn’t just prevent unauthorized connections from the internet (and perhaps intercept some connections to the internet, too), but also blocks inter-process-communication inside the same computer. Note that since _Maxima_ is being run by a Lisp processor the process communication that is blocked does not necessarily have to be named "maxima". Common names of the program that opens the network connection would be sbcl, gcl, ccl, lisp.exe, or similar names.
fr: Puisque _Maxima_ (le programme qui effectue les calculs mathématiques) et _wxMaxima_ (qui fournit l’interface utilisateur conviviale) sont deux programmes distincts qui communiquent via une connexion réseau locale, la cause la plus probable d'un dysfonctionnement est que cette connexion ne s'établit pas correctement. Par exemple, un pare-feu peut être configuré non seulement pour bloquer les connexions non autorisées depuis Internet (et éventuellement intercepter certaines connexions sortantes), mais aussi pour empêcher la communication entre processus sur un même ordinateur. Notez que, comme Maxima est exécuté via un processeur Lisp, le processus bloqué ne porte pas nécessairement le nom "maxima". Les noms usuels pour le programme ouvrant la connexion réseau peuvent être sbcl, gcl, ccl, lisp.exe, ou des noms similaires.

note: type: Plain text
en: On Unix computers another possible reason would be that the loopback network that provides network connections between two programs in the same computer isn’t properly configured.
fr: Sur les ordinateurs Unix, une autre cause possible serait que le réseau loopback, qui permet les connexions entre deux programmes sur le même ordinateur, ne soit pas correctement configuré.

note: type: Plain text
en: ## How to save data from a broken .wxmx file
fr: ## Comment récupérer les données d’un fichier .wxmx corrompu

note: type: Plain text
en: Internally most modern XML-based formats are ordinary zip files. _WxMaxima_ doesn’t turn on compression, so the contents of `.wxmx` files can be viewed in any text editor.
fr: En informatique, la plupart des formats modernes basés sur XML sont en réalité des fichiers zip ordinaires. _WxMaxima_ n’active pas la compression, donc le contenu des fichiers `.wxmx` peut être consulté avec n’importe quel éditeur de texte.

note: type: Plain text
en: If the zip signature at the end of the file is still intact after renaming a broken `.wxmx` file to `.zip` most operating systems will provide a way to extract any portion of the information that is stored inside it. This can be done when there is a need of recovering the original image files from a text processor document. If the zip signature isn’t intact that does not need to be the end of the world: If _wxMaxima_ during saving detected that something went wrong there will be a `.wxmx~` file whose contents might help.
fr: Si la signature du zip à la fin du fichier est toujours intacte après avoir renommé un fichier `.wxmx` corrompu en `.zip`, la plupart des systèmes d’exploitation permettront d’extraire une partie des informations qu’il contient. Cette méthode est souvent utilisée pour récupérer les fichiers image originaux d’un document issu d'un traitement de texte. Si la signature du zip n’est plus intacte, ce n’est pas forcément une impasse : si _wxMaxima_ a détecté une erreur lors de l’enregistrement, un fichier `.wxmx~` aura probablement été créé et son contenu pourrait s’avérer utile.

note: type: Plain text
en: And even if there isn’t such a file: The `.wxmx` file is a container format and the XML portion is stored uncompressed. It it is possible to rename the `.wxmx` file to a `.txt` file and to use a text editor to recover the XML portion of the file’s contents (it starts with `<?xml version="1.0" encoding="UTF-8"?>` and ends with `</wxMaximaDocument>`. Before and after that text you will see some unreadable binary contents in the text editor).
fr: Et même s’il n’existe pas un tel fichier : le format `.wxmx` est un format conteneur et la partie XML y est stockée sans compression. Il est possible de renommer le fichier `.wxmx` en `.txt` et d’utiliser un éditeur de texte pour récupérer la portion XML du contenu (elle commence par `<?xml version="1.0" encoding="UTF-8"?>` et se termine par `</wxMaximaDocument>`. Avant et après ce texte, vous verrez du contenu binaire illisible dans l’éditeur).

note: type: Plain text
en: If a text file containing only these contents (e.g. copy and paste this text into a new file) is saved as a file ending in `.xml`, _wxMaxima_ will know how to recover the text from the document.
fr: Si vous enregistrez un fichier texte contenant uniquement ce contenu (par exemple, en copiant et collant ce texte dans un nouveau fichier) avec une extension `.xml`, _wxMaxima_ saura comment récupérer le texte du document.

note: type: Plain text
en: ## I want some debug info to be displayed on the screen before my command has finished
fr: ## Je souhaite afficher des informations de débogage à l’écran avant que ma commande ne soit terminée

note: type: Plain text
en: Normally _wxMaxima_ waits for the whole 2D formula to be transferred before it begins to typeset. This saves time for making many attempts to typeset a only partially completed equation. There is a `disp` command, though, that will provide debug output immediately and without waiting for the current _Maxima_ command to finish:
fr: Normalement, _wxMaxima_ attend que la formule 2D soit transférée en totalité avant de commencer la composition typographique. Cela permet d’économiser du temps en évitant de tenter d'écrire une équation incomplète. Cependant, il existe une commande `disp` qui affiche immédiatement des informations de débogage, sans attendre la fin de l’exécution de la commande _Maxima_ en cours :

note: type: Plain text
en: ```maxima
    for i:1 thru 10 do (
       disp(i),
       /* (sleep n) is a Lisp function, which can be used */
       /* with the character "?" before. It delays the */
       /* program execution (here: for 3 seconds) */
       ?sleep(3)
    )$
    ```
fr: ``maxima
    for i:1 thru 10 do (
       disp(i),
       /* (sleep n) is a Lisp function, which can be used */
       /* with the character "?" before. It delays the */
       /* program execution (here: for 3 seconds) */
       ?sleep(3)
    )$
    ```

note: type: Plain text
en: Alternatively one can look for the `wxstatusbar()` command above.
fr: Sinon, on peut utiliser la commande `wxstatusbar()` mentionnée ci-dessus.

note: type: Plain text
en: ## Plotting only shows a closed empty envelope with an error message
fr: ## La création d'un graphique n'affiche qu'une enveloppe vide encadrée avec un message d'erreur

note: type: Plain text
en: This means that _wxMaxima_ could not read the file _Maxima_ that was supposed to instruct _Gnuplot_ to create.
fr: Cela signifie que _wxMaxima_ n'a pas pu lire le fichier généré par _Maxima_, qui était censé donner les instructions à _Gnuplot_ pour créer le graphique.

note: type: Plain text
en: Possible reasons for this error are:
fr: Les causes possibles de cette erreur sont :

note: type: Plain text
en: ## Plotting an animation results in “error: undefined variable”
fr: ## Le tracé d'une animation génère l'erreur "error: undefined variable"

note: type: Plain text
en: The value of the slider variable by default is only substituted into the expression that is to be plotted if it is visible there. Using a `subst` command that substitutes the slider variable into the equation to plot resolves this problem. At the end of section [Embedding animations into the spreadsheet](#embedding-animations-into-the-spreadsheet), you can see an example.
fr: Par défaut, la valeur du paramètre pour le curseur n'est substituée dans l'expression à tracer que si elle y est visible. L'utilisation d'une commande `subst` qui substitue la variable du curseur dans l'équation à tracer résout ce problème. À la fin de la section [Intégrer des animations dans le notebook](#embedding-animations-into-the-spreadsheet), vous pouvez voir un exemple.

note: type: Plain text
en: ## I lost cell content and undo doesn’t remember
fr: ## J’ai perdu le contenu d’une cellule et la fonction Annuler ne le restaure pas

note: type: Plain text
en: There are separate undo functions for cell operations and for changes inside of cells so chances are low that this ever happens. If it does there are several methods to recover data:
fr: Il existe des fonctions Annuler distinctes pour les opérations sur les cellules et pour les modifications à l’intérieur des cellules, donc il est peu probable que cela arrive. Si cela se produit, plusieurs méthodes permettent de récupérer les données :

note: type: Plain text
en: ## _WxMaxima_ starts up with the message “Maxima process terminated.”
fr: ## _WxMaxima_ démarre avec le message  Maxima process terminated

note: type: Plain text
en: One possible reason is that _Maxima_ cannot be found in the location that is set in the “Maxima” tab of _wxMaxima_’s configuration dialog and therefore won’t run at all. Setting the path to a working _Maxima_ binary should fix this problem.
fr: Une cause possible est que le programme _Maxima_ n’est pas trouvé à l’emplacement indiqué dans l’onglet Maxima de la boîte de dialogue de configuration de _wxMaxima_, ce qui l’empêche de démarrer. Vérifiez et corrigez le chemin vers l’exécutable _Maxima_ pour résoudre ce problème.

note: type: Plain text
en: ## Maxima is forever calculating and not responding to input
fr: ## Maxima calcule indéfiniment et ne répond plus aux commandes entrées

note: type: Plain text
en: It is theoretically possible that _wxMaxima_ doesn’t realize that _Maxima_ has finished calculating and therefore never gets informed it can send new data to _Maxima_. If this is the case “Trigger evaluation” might resynchronize the two programs.
fr: Il est théoriquement possible que _wxMaxima_ ne détecte pas que _Maxima_ a terminé ses calculs et, de ce fait, n’autorise pas l’envoi de nouvelles données. Dans ce cas, l’option Déclencher l’évaluation (« Trigger evaluation ») peut resynchroniser les deux programmes.

note: type: Plain text
en: ## My SBCL-based _Maxima_ runs out of memory
fr: ## Mon _Maxima_ basé sur SBCL manque de mémoire

note: type: Plain text
en: The Lisp compiler SBCL by default comes with a memory limit that allows it to run even on low-end computers. When compiling a big software package like Lapack or dealing with extremely big lists of equations this limit might be too low. In order to extend the limits, SBCL can be provided with the command line parameter `--dynamic-space-size` that tells SBCL how many megabytes it should reserve. A 32bit Windows-SBCL can reserve up to 999 Megabytes. A 64-bit SBCL version running on Windows can be instructed to use more than the about 1280 Megabytes compiling Lapack needs.
fr: Le compilateur Lisp SBCL est configuré par défaut avec une limite de mémoire qui lui permet de fonctionner même sur des ordinateurs peu puissants. Cependant, lors de la compilation de gros packages logiciels comme Lapack ou du traitement de listes d'équations extrêmement longues, cette limite peut s'avérer insuffisante. Pour l'augmenter, vous pouvez utiliser le paramètre en ligne de commande `--dynamic-space-size` lors du lancement de SBCL, qui indique combien de mégaoctets doivent être réservés. - Une version 32 bits de SBCL sous Windows peut réserver jusqu'à 999 Mo. - Une version 64 bits sous Windows peut aller au-delà des 1280 Mo nécessaires pour compiler Lapack.

note: type: Plain text
en: One way to provide _Maxima_ (and thus SBCL) with command line parameters is the "Additional parameters for Maxima" field of _wxMaxima_’s configuration dialogue.
fr: Une façon de fournir des paramètres en ligne de commande à _Maxima_ (et donc à SBCL) est d’utiliser le champ "Paramètres supplémentaires pour Maxima" dans la boîte de dialogue de configuration de _wxMaxima_.

note: type: Plain text
en: ![sbcl memory](./sbclMemory.png){ id=img_sbclMemory }
fr: ![mémoire pour sbcl](./sbclMemory.png){ id=img_sbclMemory }

note: type: Plain text
en: ## Input sometimes is sluggish/ignoring keys on Ubuntu
fr: ## Sous Ubuntu, la saisie est parfois lente ou certaines touches sont ignorées

note: type: Plain text
en: Installing the package `ibus-gtk` should resolve this issue. See ([https://bugs.launchpad.net/ubuntu/+source/wxwidgets3.0/+bug/1421558](https://bugs.launchpad.net/ubuntu/+source/wxwidgets3.0/+bug/1421558)) for details.
fr: L'installation du paquet 'ibus-gtk' devrait résoudre ce problème. Pour plus de détails, voir : [https://bugs.launchpad.net/ubuntu/+source/wxwidgets3.0/+bug/1421558](https://bugs.launchpad.net/ubuntu/+source/wxwidgets3.0/+bug/1421558).

note: type: Plain text
en: ## _WxMaxima_ halts when _Maxima_ processes Greek characters or Umlauts
fr: ## _WxMaxima_ se fige lorsque _Maxima_ traite des caractères grecs ou des lettres accentuées (comme les umlauts)

note: type: Plain text
en: If your _Maxima_ is based on SBCL the following lines have to be added to your `.sbclrc`:
fr: Si votre _Maxima_ est basé sur SBCL, ajoutez les lignes suivantes à votre fichier `.sbclrc` :

note: type: Plain text
en: The folder where this file has to be placed is system- and installation-specific. But any SBCL-based _Maxima_ that already has evaluated a cell in the current session will happily tell where it can be found after getting the following command:
fr: Le dossier où ce fichier doit être placé dépend du système et de l’installation. Cependant, toute version de _Maxima_ basée sur SBCL, ayant déjà évalué une cellule durant la session en cours, peut gentiment indiquer son emplacement après exécution de la commande suivante :

note: type: Plain text
en: ## Note concerning Wayland (recent Linux/BSD distributions)
fr: ## Remarque concernant Wayland (distributions Linux/BSD récentes)

note: type: Plain text
en: There seem to be issues with the Wayland Display Server and wxWidgets.  WxMaxima may be affected, e.g. that sidebars are not moveable.
fr: Il semble y avoir des problèmes de compatibilité entre le serveur d'affichage Wayland et wxWidgets. WxMaxima peut en être affecté, par exemple avec des barres latérales qui ne peuvent pas être déplacées.

note: type: Plain text
en: You can either disable Wayland and use X11 instead (globally)  or just tell, that wxMaxima should use the X Window System by setting: `GDK_BACKEND=x11`
fr: Vous pouvez soit : - désactiver Wayland et utiliser X11 à la place (de manière globale), - ou forcer WxMaxima à utiliser le système X Window en définissant la variable d’environnement :  `GDK_BACKEND=x11`

note: type: Plain text
en: E.g. start wxMaxima with:
fr: Par exemple, lancez WxMaxima avec la commande :

note: type: Plain text
en: ## Why is the integrated manual browser not offered on my Windows PC?
fr: ## Pourquoi le navigateur pour le manuel intégré n’est-il pas disponible sur mon PC Windows ?

note: type: Plain text
en: ## Why is the external manual browser not working on my Linux box?
fr: ## Pourquoi le navigateur pour le manuel externe ne fonctionne-t-il pas sur ma machine Linux ?

note: type: Plain text
en: ## Can I make _wxMaxima_ output both image files and embedded plots at once?
fr: ## Puis-je faire en sorte que _wxMaxima_ génère à la fois des fichiers image et des graphiques en ligne en même temps ?

note: type: Plain text
en: The worksheet embeds `.png files. _WxMaxima_ allows the user to specify where they should be generated:
fr: Le notebook intègre les fichiers `.png`. _WxMaxima_ permet à l'utilisateur de spécifier où ces fichiers doivent être générés :

note: type: Plain text
en: If a different format is to be used, it is easier to generate the images and then import them into the worksheet again:
fr: Si vous souhaitez utiliser un format différent, il est plus simple de générer les images séparément, puis de les réimporter dans le notebook :

note: type: Plain text
en: ## Can I set the aspect ratio of an embedded plot?
fr: ## Puis-je définir le rapport hauteur/largeur (aspect ratio) d’un graphique en ligne ?

note: type: Plain text
en: Use the variable `wxplot_size`:
fr: Utilisez la variable `wxplot_size` :

note: type: Plain text
en: ## After upgrading to MacOS 13.1 plot and/or draw commands output error messages like
fr: ## Après la mise à niveau vers macOS 13.1, les commandes plot et/ou draw affichent des messages d'erreur du type

note: type: Plain text
en: This might be an issue with the operating system. Disable the hiding of the menu bar (SystemSettings => Desktop & Dock => Menu Bar) might solve the issue. See [wxMaxima issue #1746](https://github.com/wxMaxima-developers/wxmaxima/issues/1746) for more information.
fr: Ce problème pourrait être lié au système d'exploitation. Désactiver le masquage automatique de la barre de menus (via Réglages Système => Bureau et Dock => Barre des menus) pourrait résoudre le problème. Pour plus d'informations, voir [l'issue wxMaxima #1746](https://github.com/wxMaxima-developers/wxmaxima/issues/1746).

note: type: Plain text
en: ## Is there a way to make more text fit on a LaTeX page?
fr: ## Comment faire tenir plus de texte sur une page LaTeX ?

note: type: Plain text
en: Yes. Use the [LaTeX package "geometry"](https://ctan.org/pkg/geometry) to specify the size of the borders.
fr: Oui. Utilisez le [package LaTeX "geometry"](https://ctan.org/pkg/geometry) pour définir la taille des marges.

note: type: Plain text
en: You can add the following line to the LaTeX preamble (for example by using the respective field in the config dialogue ("Export"->"Additional lines for the TeX preamble"), to set borders of 1cm):
fr: Vous pouvez ajouter la ligne suivante dans le préambule LaTeX (par exemple via le champ dédié dans la fenêtre de configuration : ("Export" → "Lignes supplémentaires pour le préambule TeX") pour régler les marges à 1 cm :

note: type: Plain text
en: ## Is there a dark mode?
fr: ## Un mode sombre existe-t-il ?

note: type: Plain text
en: If wxWidgets is new enough, _wxMaxima_ will automatically be in dark mode if the rest of the operating system is. The worksheet itself is by default equipped with a bright background. But it can be configured otherwise. Alternatively, there is a `View/Invert worksheet brightness` menu entry that allows to quickly convert the worksheet from dark to bright and vice versa.
fr: Si wxWidgets est suffisamment récent, _wxMaxima_ passera automatiquement en mode sombre si le système d'exploitation l'est également. Par défaut, la feuille de travail a un fond clair, mais cela peut être personnalisé. Sinon, il existe une option 'Affichage/Inverser la luminosité de la feuille' qui permet de basculer rapidement entre un fond clair et un fond sombre.

note: type: Plain text
en: ## _WxMaxima_ sometimes hangs for several seconds once in the first minute
fr: ## _WxMaxima_ se fige parfois pendant plusieurs secondes lors de la première minute d'utilisation

note: type: Plain text
en: ![Locale warning](./locale-warning.png){ id=img_locale_warning}
fr: ![Avertissement sur la langue locale](./locale-warning.png){ id=img_locale_warning}

note: type: Plain text
en: These locales maybe not present in the system. On Ubuntu/Debian systems they can be generated using: `dpkg-reconfigure locales`
fr: Ces langues locales peuvent ne pas être présentes dans le système. Sur les systèmes Ubuntu/Debian, elles peuvent être générées avec : `dpkg-reconfigure locales`

note: type: Plain text
en: ## How can a Maxima script determine, if it is running under wxMaxima or command line Maxima?
fr: ## Comment un script Maxima peut-il déterminer s'il s'exécute sous wxMaxima ou en ligne de commande ?

note: type: Plain text
en: If wxMaxima is used, the Maxima variable `maxima_frontend` is set to `wxmaxima`. The Maxima variable `maxima_frontend_version` contains the wxMaxima version in this case.
fr: Si wxMaxima est utilisé, la variable Maxima `maxima_frontend` est définie sur `wxmaxima`. Dans ce cas, la variable Maxima `maxima_frontend_version` contient la version de wxMaxima.

note: type: Plain text
en: If no frontend is used (you are using command line Maxima), these variables are `false`.
fr: Si aucun programme pour le frontend n'est utilisé (si vous utilisez Maxima en ligne de commande), ces variables valent `false`.

note: type: Plain text
en: # Command-line arguments
fr: # Arguments en ligne de commande

note: type: Plain text
en: Usually you can start programs with a graphical user interface just by clicking on a desktop icon or desktop menu entry. WxMaxima - if started from the command line - still provides some command-line switches, though.
fr: Généralement, les programmes dotés d'une interface graphique se lancent simplement en cliquant sur une icône ou une entrée de menu. WxMaxima, lorsqu'il est démarré depuis la ligne de commande, accepte néanmoins certains arguments.

note: type: Bullet: '- '
en: `-v` or `--version`: Output the version information
fr: `-v` ou `--version` : affiche les informations de version

note: type: Bullet: '- '
en: `-h` or `--help`: Output a short help text
fr: `-h` ou `--help` : affiche un texte d'aide succinct

note: type: Bullet: '- '
en: `-o` or `--open=<str>`: Open the filename given as an argument to this command-line switch
fr: `-o` ou `--open=<fichier>` : ouvre le fichier spécifié en argument de cette option de la ligne de commande

note: type: Bullet: '- '
en: `-e` or `--eval`: Evaluate the file after opening it.
fr: `-e` ou `--eval` : évalue le fichier après l'avoir ouvert.

note: type: Bullet: '- '
en: `-b` or `--batch`: If the command-line opens a file all cells in this file are evaluated and the file is saved afterward. This is for example useful if the session described in the file makes _Maxima_ generate output files. Batch-processing will be stopped if _wxMaxima_ detects that _Maxima_ has output an error and will pause if _Maxima_ has a question: Mathematics is somewhat interactive by nature so a completely interaction-free batch processing cannot always be guaranteed.
fr: `-b` ou `--batch` : si un fichier est ouvert en ligne de commande, toutes ses cellules sont évaluées et le fichier est ensuite enregistré. Cela peut être utile, par exemple, si la session décrite dans le fichier amène _Maxima_ à générer des fichiers de sortie. Le traitement en mode batch s'arrête si _wxMaxima_ détecte une erreur émise par _Maxima_, et s'interrompt au cas où _Maxima_ pose une question : la nature interactive des mathématiques ne permet pas toujours un traitement entièrement automatisé.

note: type: Plain text
en: - `--logtostderr`:                 Log all "debug messages" sidebar messages to stderr, too.
    - `--pipe`:                        Pipe messages from Maxima to stdout.
    - `--exit-on-error`:               Close the program on any maxima error.
    - `-f` or `--ini=<str>`: Use the init file that was given as an argument to this command-line switch
    - `-u`, `--use-version=<str>`:     Use maxima version `<str>`.
    - `-l`, `--lisp=<str>`:              Use a Maxima compiled with Lisp compiler `<str>`.
    - `-X`, `--extra-args=<str>`:        Allows to specify extra Maxima arguments
    - `-m` or `--maxima=<str>`:    allows specifying the location of the _maxima_ binary
    - `--enableipc`: Lets Maxima control wxMaxima via interprocess communications. Use this option with care.
    - `--wxmathml-lisp=<str>`:   Location of wxMathML.lisp (if not the built-in should be used, mainly for developers).
fr: - `--logtostderr` : redirige aussi les messages de débogage (barre latérale) vers stderr.
    - `--pipe` : transmet les messages de Maxima vers stdout.
    - `--exit-on-error` : ferme le programme en cas d’erreur Maxima.
    - `-f` ou `--ini=<fichier>` : utilise le fichier d’initialisation spécifié en argument.
    - `-u`, `--use-version=<version>` : utilise la version `<version>` de Maxima.
    - `-l`, `--lisp=<compilateur>` : utilise une version de Maxima compilée avec le compilateur Lisp `<compilateur>`.
    - `-X`, `--extra-args=<args>` : permet de passer des arguments supplémentaires à Maxima.
    - `-m` ou `--maxima=<chemin>` : spécifie l’emplacement du binaire maxima.
    - `--enableipc` : permet à Maxima de contrôler wxMaxima via une communication inter-processus (à utiliser avec prudence).
    - `--wxmathml-lisp=<fichier>` : indique l’emplacement de `wxMathML.lisp` (pour remplacer la version intégrée, principalement pour les développeur·ses).

note: type: Plain text
en: Instead of a minus, some operating systems might use a dash in front of the command-line switches.
fr: Certains systèmes d'exploitation peuvent utiliser un tiret long (—) au lieu d'un tiret court (-) devant les options en ligne de commande.

note: type: Plain text
en: # About the program, contributing to wxMaxima
fr: # À propos du logiciiel et des contributions à wxMaxima

note: type: Plain text
en: wxMaxima is mainly developed using the programming language C++ using the [wxWidgets framework](https://www.wxwidgets.org), as build system we use [CMake](https://www.cmake.org), a small part is written in Lisp. You can contribute to wxMaxima, join the wxMaxima project at <https://github.com/wxMaxima-developers/wxmaxima>, if you have knowledge of these programming languages and want to help and contribute to the open source project wxMaxima.
fr: wxMaxima est principalement développé en C++ avec le framework [wxWidgets](https://www.wxwidgets.org), et utilise [CMake](https://www.cmake.org) comme système de build. Une petite partie est écrite en Lisp. Si vous maîtrisez ces langages et souhaitez contribuer à ce projet open source, vous pouvez rejoindre l’équipe sur [GitHub](https://github.com/wxMaxima-developers/wxmaxima).

note: type: Plain text
en: But not only programmers are necessary! You can also contribute to wxMaxima, if you help to improve the documentation, find and report bugs (and maybe bugfixes), suggest new features, help to translate wxMaxima or the manual to your language (read the README.md in the [locale subdirectory](https://github.com/wxMaxima-developers/wxmaxima/tree/main/locales) how wxMaxima and the manual can be translated).
fr: Mais les programmeurs ne sont pas les seul·es à pouvoir contribuer ! Vous pouvez aussi aider à améliorer wxMaxima en améliorant la documentation, en signalant (ou corrigeant) des bugs, en proposant de nouvelles fonctionnalités, en traduisant l’interface ou le manuel dans votre langue (consultez le fichier README.md dans le [dossier locales](https://github.com/wxMaxima-developers/wxmaxima/tree/main/locales) pour savoir comment procéder).

note: type: Plain text
en: Or answer questions of other users in the discussion forum.
fr: Ou répondre aux questions d'autres utilisateurs sur le forum de discussion.

note: type: Plain text
en: The source code of wxMaxima is documented using Doxygen [here](https://wxmaxima-developers.github.io/wxmaxima/Doxygen-documentation/).
fr: Le code source de wxMaxima est documenté avec Doxygen, disponible [ici](https://wxmaxima-developers.github.io/wxmaxima/Doxygen-documentation/).

note: type: Plain text
en: The program is nearly self-contained, so except for system libraries (and the wxWidgets library), no external dependencies (like graphic files or the Lisp part (the `wxmathML.lisp`-file) is needed, these files are included in the executable.
fr: Le programme est quasi complet : hormis les bibliothèques système (et la bibliothèque wxWidgets), il ne nécessite aucune dépendance externe (comme des fichiers graphiques ou le logiciel Lisp.   Les éléments comme le fichier ( `wxmathML.lisp`) sont intégrés directement dans l'exécutable.

note: type: Plain text
en: If you are a developer, you might want to try out a modified `wxmathML.lisp`-file without recompiling everything, one can use the command line option `--wxmathml-lisp=<str>` to use another Lisp file, not the included one.
fr: Si vous êtes développeur et que vous souhaitez tester une version modifiée du fichier `wxmathML.lisp`  sans tout recompiler, vous pouvez utiliser l'option en ligne de commande : `--wxmathml-lisp=<chemin>` pour spécifier un autre fichier Lisp à la place de celui intégré à la version actuelle.
