Lisez-moi S.V.P. 

3 Le balisage de présentation

Table des matières : Le langage de balisage mathématique (MathML) version 2.0
Chapitre précédent : 2. Les principes fondamentaux de MathML
Chapitre suivant : 4. Le balisage de contenu

3.1 Introduction

Ce chapitre définit les éléments de présentation de MathML pouvant servir à décrire la structure de mise en page d'une notation mathématique.

3.1.1 Ce que les éléments de présentation représentent

Les éléments de présentation correspondent aux constructeurs en notation traditionnelle des mathématiques, c'est-à-dire, aux types de symboles et aux structures de construction d'expression de base d'après lesquels se construit tout morceau particulier en notation traditionnelle des mathématiques. En raison de l'importance de la notation visuelle traditionnelle, les descriptions des constructions de notation que les éléments représentent sont données ici en termes visuels. Néanmoins, les éléments sont indépendants du médium, c'est-à-dire qu'ils ont aussi été conçus pour contenir assez d'informations pour leur bon rendu sonore. Certains attributs de ces éléments n'ont de sens que pour les médias visuels mais, pour la plupart, un traitement sonore analogue est aussi possible (par exemple, par correspondance entre la durée et l'étalement horizontal).

Les éléments de présentation MathML suggèrent seulement (c.à.d., n'imposent pas) des rendus possibles, afin de permettre un rendu dépendant d'un média et des préférences de style personnelles. Cette spécification décrit en détails les règles d'un rendu visuel suggéré mais un moteur de rendu MathML est libre d'utiliser ses propres règles tant que ses rendus sont intelligibles.

Les éléments de présentation servent à exprimer la structure syntaxique de la notation mathématique, un peu comme les titres, les chapitres et les paragraphes représentent la structure syntaxique supérieure d'un document textuel. Ainsi, par exemple, une seule rangée d'identificateurs et d'opérateurs, telle que x + a / b, souvent ne sera pas représentée simplement par un élément mrow (qui est rendu par la rangée horizontale de ses arguments) mais par plusieurs éléments mrow imbriqués, correspondant aux sous-expressions imbriquées qui composent l'expression mathématique :

<mrow>
  <mi> x </mi>
  <mo> + </mo>
  <mrow>
    <mi> a </mi>
    <mo> / </mo>
    <mi> b </mi>
  </mrow>
</mrow>

De même, les exposants ne s'accrochent pas simplement au caractère précédent mais aux expressions entières constituant leur base. Cette structure permet un meilleur rendu des mathématiques, en particulier lorsque l'auteur du document ne connaît pas les détails concernant l'environnement de rendu comme les chasses affichées ; cela facilite également beaucoup l'interprétation automatique des structures mathématiques représentées.

Certains caractères MathML servent à nommer des opérateurs ou des identificateurs rendus en notation traditionnelle pareils à d'autres symboles, tels que &DifferentialD;, &ExponentialE; ou &ImaginaryI;, ou d'autres opérateurs normalement invisibles, tels que &InvisibleTimes;, &ApplyFunction; ou &InvisibleComma;. Ce sont des symboles ou objets de notation distincts, ce que met en évidence leur rendu sonore distinct et parfois les effets sur les sauts de ligne et les espacements dans un rendu visuel, et comme tels ils devraient être représentés par des références d'entités particulières appropriées. Par exemple, l'expression représentée visuellement par f(x) se prononcera habituellement en français par f de x plutôt que simplement f x ; on peut l'exprimer en MathML à l'aide d'un opérateur &ApplyFunction; après le f, qui sera rendu (ici) de façon sonore par de.

La liste complète des entités MathML est décrite dans le chapitre 6 Les caractères, les entités et les fontes.

3.1.2 La terminologie employée dans ce chapitre

On recommande fortement de lire avant le présent chapitre, la section 2.4 La syntaxe et la grammaire de MathML à propos de la syntaxe et de la grammaire de MathML, laquelle contient des informations importantes concernant les notations et les conventions de MathML. En particulier, dans ce chapitre, le lecteur est censé connaître la terminologie XML de base décrite dans la section 2.4.2 Une introduction à la syntaxe XML et les notations et conventions pour les valeurs d'attribut décrites dans la section 2.4.4 Les valeurs des attributs MathML.

Le reste de la section introduit la terminologie et les conventions spécifiques de MathML employées dans ce chapitre.

3.1.2.1 Les types des éléments de présentation

Les éléments de présentation se rangent en deux classes. Les éléments atomiques représentent des symboles, des noms, des nombres, des étiquettes, etc., individuels. En général, les atomes contiennent seulement des caractères. Les seules exceptions sont constituées par l'élément d'alignement vertical malignmark, l'élément mglyph et les références d'entités. Les schémas de disposition bâtissent les expressions par morceaux et ils ne peuvent contenir que des éléments (hormis les blancs qu'ils ignorent). Il y a aussi quelques éléments vides qui servent uniquement en conjonction avec certains schémas de disposition.

Tous les symboles individuels dans une expression mathématique devraient être représentés par des éléments atomiques MathML. Les principaux types d'éléments atomiques MathML sont des identificateurs (par exemple, des variables ou des noms de fonction), des nombres et des opérateurs (y compris des délimiteurs, telles que les parenthèses, et des séparateurs, telles que les virgules). Il y a aussi des éléments atomiques qui représentent du texte ou du blanc, dont le rôle est plus esthétique qu'il ne revêt une signification mathématique, et qui représentent des chaînes littérales pour une compatibilité avec les systèmes de calcul algébrique. Remarquez, quoiqu'un élément atomique représente un seul symbole significatif (nom, nombre, étiquette, symbole mathématique, etc.), que ces symboles peuvent se composer de plusieurs caractères. Par exemple, les expressions sin et 24 sont représentés, respectivement, par les seuls atomes <mi>sin</mi> et <mn>24</mn>.

En notation traditionnelle des mathématiques, les expressions se construisent récursivement avec des expressions plus petites et, finalement, avec des symboles seuls, ces parties sont alors regroupées et positionnées à l'aide d'un jeu réduit de structures de notation, que l'on peut assimiler à des constructeurs d'expression. Dans MathML, les expressions se construisent de la même façon, et les schémas de disposition jouent le rôle de constructeurs d'expression. Le schéma de disposition définit la façon dont les sous-expressions sont assemblées en expressions plus grandes. La terminologie provient de ce que chaque schéma de disposition correspond à une façon différente de disposer ses sous-expressions afin de former une expression plus grande dans la composition traditionnelle des mathématiques.

3.1.2.2 La terminologie des autres classes d'éléments et leurs relations

La terminologie employée dans ce chapitre pour les classes spéciales d'éléments et pour les relations entre ces éléments est la suivante : les éléments de présentation sont les éléments MathML définis dans ce chapitre ; ces éléments sont listés dans la section 3.1.6 Le sommaire des éléments de présentation ; les éléments de contenu sont les éléments MathML définis dans le chapitre 4 Le balisage de contenu ; ces éléments sont listés dans la section 4.4 Les éléments de balisage du contenu.

Une expression MathML représente une seule instance de n'importe quel élément de présentation, à l'exception des éléments vides none ou mprescripts, ou une seule instance de n'importe quel élément de contenu admissible en contenu d'un élément de présentation (décrit dans la section 5.2.4 Le balisage de contenu inclus dans un balisage de présentation). Une sous-expression d'une expression E est une expression MathML faisant partie du contenu de E, que ce soit directement ou indirectement, c'est-à-dire, un sous-élément de E ou non.

Puisque les schémas de disposition attribuent une signification spéciale au nombre et/ou aux positions de leurs enfants, l'enfant d'un schéma de disposition est également appelé un argument de cet élément. En conséquence des définitions précédentes, le contenu d'un schéma de disposition se compose exactement d'une séquence de zéro à plusieurs éléments qui sont ses arguments.

3.1.3 Les arguments obligatoires

Plusieurs éléments décrits ici imposent un nombre spécifique d'arguments (toujours 1, 2 ou 3). Dans les descriptions détaillées de la syntaxe des éléments fournies après, le nombre des arguments obligatoires est indiqué implicitement en nommant les arguments aux diverses positions. Quelques éléments ont d'autres contraintes sur le nombre ou le type des arguments ; elles sont décrites avec l'élément individuel. Par exemple, certains éléments acceptent une séquence de zéro à plusieurs arguments, c'est-à-dire qu'ils peuvent apparaître sans argument du tout.

Remarquez que les éléments MathML codant un espace rendu comptent en tant qu'arguments des éléments au sein desquels ils apparaissent. Cf. la section 3.2.7 L'espacement (mspace) pour une discussion sur l'utilisation correcte de ces éléments pareils à des espaces.

3.1.3.1 Les éléments mrow inférés

Les éléments listés dans le tableau suivant comme nécessitant 1* argument (msqrt, mstyle, merror, menclose, mpadded, mphantom, mtd et math) acceptent en réalité un nombre quelconque d'arguments. Toutefois, si le nombre d'arguments est 0 ou supérieur à 1, ces éléments traitent leurs contenus comme un seul mrow inféré formé à partir de tous leurs arguments. Bien que l'élément math ne soit pas un élément de présentation, il est listé ci-dessous par souci d'exhaustivité.

Par exemple :

<mtd>
</mtd>

Cette expression est traitée comme si c'était :

<mtd>
  <mrow>
  </mrow>
</mtd>

Et, dans cet exemple :

<msqrt>
  <mo> - </mo>
  <mn> 1 </mn>
</msqrt>

L'expression est traitée comme si c'était :

<msqrt>
  <mrow>
    <mo> - </mo>
    <mn> 1 </mn>
  </mrow>
</msqrt>

Cette caractéristique permet aux données MathML de ne pas contenir nombre d'éléments mrow (et aux auteurs de ne pas s'en soucier) qui auraient été nécessaires sinon.

Dans les descriptions, dans ce chapitre, des comportements de rendu des éléments listés précédemment, on peut supposer que leur contenu se compose exactement d'une seule expression, qui peut être un élément mrow formé de cette façon à partir de leurs arguments. Toutefois, le compte de leurs argument est signalé dans le tableau suivant comme valant 1*, puisqu'on les comprend tout naturellement comme agissant sur une seule expression.

3.1.3.2 Le tableau de contrainte d'arguments

Par commodité, voici le tableau des contraintes de compte d'arguments pour chaque élément, et des rôles des arguments individuels lorsqu'ils sont distingués. Un compte d'argument de 1* indique un élément mrow inféré, comme décrit précédemment.

Élément Contrainte de compte d'arguments Rôles des arguments (différents selon leur position)
mrow 0 à plusieurs  
mfrac 2 numérateur dénominateur
msqrt 1*  
mroot 2 base indice
mstyle 1*  
merror 1*  
mpadded 1*  
mphantom 1*  
mfenced 0 à plusieurs  
menclose 1*  
msub 2 base indice
msup 2 base exposant
msubsup 3 base indice exposant
munder 2 base écriture dessous
mover 2 base écriture dessus
munderover 3 base écriture dessous écriture dessus
mmultiscripts 1 à plusieurs base (indice exposant)* [<mprescripts/> (préécriture en indice inférieur préécriture en exposant)*]
mtable 0 à plusieurs rangées 0 à plusieurs éléments mtr, ou mlabeledtr
mlabeledtr 1 à plusieurs une étiquette et 0 à plusieurs éléments mtd
mtr 0 à plusieurs 0 à plusieurs éléments mtd
mtd 1*  
maction 1 à plusieurs selon l'attribut actiontype
math 1*  

3.1.4 Les éléments avec des comportements spéciaux

Certains éléments de présentation MathML exhibent des comportement spéciaux dans certains contextes. Ces comportements spéciaux sont abordés dans les descriptions d'élément détaillées à suivre. Toutefois, par commodité, certaines classes de comportement spécial, les plus importantes, sont listées ici.

Certains éléments sont assimilés à des blancs ; ils sont définis dans la section 3.2.7 L'espacement (mspace). Cette définition affecte certaines des règles de rendu suggéré pour les éléments mo (section 3.2.5 Les opérateurs, les délimiteurs, les séparateurs ou les accents (mo)).

Certains éléments, par exemple msup, ont la capacité d'embellir les opérateurs qui sont leur premier argument. Ces éléments sont listés dans la section 3.2.5 Les opérateurs, les délimiteurs, les séparateurs ou les accents (mo), qui définit précisément ce qu'est un opérateur embelli et explique dans quelle mesure les règles de rendu suggéré pour les opérateurs étirables sont affectées.

Certains éléments traitent leurs arguments comme étant ceux d'un élément mrow inféré s'ils n'ont pas reçu exactement un argument, comme expliqué dans la section 3.1.3 Les arguments obligatoires.

Dans MathML 1.x, l'élément mtable pouvait inférer des éléments mtr autour de ses arguments, et l'élément mtr pouvait inférer des éléments mtd. Dans MathML 2.0, les éléments mtr et mtd doivent être explicites. Toutefois, pour la rétrocompatibilité, les moteurs de rendu peuvent continuer de gérer les éléments mtr et mtd inférés.

3.1.5 La disposition bidirectionnelle

L'expression disposition bidirectionnelle se rapporte au fait que les lettres de certaines écritures, notamment l'arabe et l'hébreu, s'écrivent de droite à gauche, et que les mêler à des nombres ou à des lettres issues d'écritures de gauche à droite occasionne des jets de texte en deux directions opposées dans la même ligne ou le même paragraphe.

Pour un texte ordinaire, la norme Unicode définit un algorithme bidirectionnel [Bidi]. Cet algorithme suppose que l'ordre des caractères en arrière-boutique est logique (c.à.d., dans l'ordre où ils seraient prononcés ou tapés) et définit comment les caractères sont réarrangés pour l'affichage, en fonction des propriétés des caractères et d'autres directives. Les langages HTML, CSS, XSL et SVG adoptent cet algorithme et fournissent des moyens de le contrôler via des balises ou des styles.

Dans les expressions mathématiques, une disposition bidirectionnelle est plus difficile que dans un texte. Cela est en partie dû à la nature bidimensionnelle de la disposition mathématique et au fait que les relations spatiales sont souvent employées, dans la notation mathématique, pour véhiculer une signification. Un autre facteur est l'absence de conventions établies pour la disposition bidirectionnelle des mathématiques, car relativement rare même dans les contextes d'écriture de droite à gauche.

Pour ces raisons, MathML 2.0 n'adopte qu'une version réduite de l'algorithme bidirectionnel Unicode, qui est décrite dans le reste de cette section.

3.1.5.1 La disposition bidirectionnelle dans les éléments atomiques

Pour les éléments atomiques MathML pouvant contenir du texte (mtext, mo, mi, mn et ms), on applique la partie implicite de l'algorithme bidirectionnel Unicode [Bidi] lorsque leur contenu est rendu visuellement (c'est-à-dire, les caractères sont réarrangés en fonction des propriétés des caractères). L'orientation de base est de gauche à droite.

La partie implicite de l'algorithme bidirectionnel Unicode est identique à une disposition directe de gauche à droite s'il n'y a qu'un seul caractère ou s'il n'y a aucun caractère de droite à gauche fort (c.à.d., aucun caractère arabe, hébreu ou assimilé).

Les applications ne sont pas obligées d'appliquer l'algorithme bidirectionnel Unicode si elles ne rendent pas les caractères de droite à gauche forts.

Veuillez remarquer que l'on devrait employer les points de code U+2135-U+2138 (SYMBOLE ALEF, SYMBOLE BÈT, SYMBOLE GUIMEL, SYMBOLE DALÈT) pour les nombres transfinis représentés en caractères hébreux. Ce sont des caractères de gauche à droite forts.

3.1.5.2 La disposition bidirectionnelle des formules mathématiques

MathML 2.0 n'aborde pas la disposition de droite à gauche, ou bidirectionnelle, dans les formules mathématiques. Seule la disposition de gauche à droite est reconnue. La disposition de droite à gauche des formules mathématiques pourra être abordée dans une future version MathML.

3.1.6 Le sommaire des éléments de présentation

3.1.6.1 Les éléments atomiques

mi identificateur
mn nombre
mo opérateur, délimiteur ou séparateur
mtext texte
mspace espacement
ms chaîne littérale
mglyph ajout de nouveaux glyphes de caractères à MathML

3.1.6.2 Les schémas généraux de disposition

mrow regroupe horizontalement un nombre quelconque de sous-expressions
mfrac forme une fraction d'après deux sous-expressions
msqrt forme une racine carrée (radical sans indice)
mroot forme un radical avec l'indice apparent
mstyle changement de style
merror enferme un message d'erreur de syntaxe provenant d'un préprocesseur
mpadded ajuste l'espacement autour du contenu
mphantom rend le contenu invisible mais préserve ses dimensions
mfenced entoure le contenu entre une paire de délimiteurs
menclose enferme le contenu avec un symbole étirable, tel qu'un signe de division longue

3.1.6.3 Les schémas d'écritures et de limites

msub accole un indice à une base
msup accole un exposant à une base
msubsup accole une paire indice-exposant à une base
munder accole une écriture dessous à une base
mover accole une écriture dessus à une base
munderover accole une paire (d'écritures) dessous-dessus à une base
mmultiscripts accole des préécritures et des indices tensoriels à une base

3.1.6.4 Les tables et les matrices

mtable une table ou une matrice
mlabeledtr une rangée dans une table ou une matrice avec une étiquette ou un numéro d'équation
mtr une rangée dans une table ou une matrice
mtd un élément dans une table ou une matrice
maligngroup et malignmark des marqueurs d'alignement

3.1.6.5 L'animation des expressions

maction associe des actions à une sous-expression

3.2 Les éléments atomiques

Les éléments atomiques du balisage de présentation sont destinés, dans leur ensemble, à représenter les plus petites unités de notation mathématique revêtant une signification. Les atomes sont grossièrement analogues aux mots d'un texte. Toutefois, à cause de la nature symbolique précise de la notation mathématique, les catégories et propriétés variées des éléments atomiques figurent en bonne place dans le balisage MathML. Par constraste, dans les données textuelles, les mots individuels ont rarement besoin d'être balisés ou stylés spécialement.

Les atomes se composent souvent d'un seul caractère indiquant un symbole mathématique. Dans d'autres cas, par exemple, les noms de fonction, il sont constitués de plusieurs caractères. En outre, puisque la notation mathématique traditionnelle fait grand usage de symboles qui se distinguent par leurs propriétés typographiques (par exemple, un g gothique en algèbre de Lie ou un x en caractère gras pour un vecteur), il faut s'assurer que les mécanismes de stylage respectent les propriétés typographiques qui véhiculent une signification. Par conséquent, les caractères, les atomes et les propriétés typographiques des symboles sont étroitement liés les uns aux autres dans MathML.

3.2.1 Les caractères MathML dans les éléments atomiques

Le balisage MathML admet les données textuelles uniquement comme partie du contenu d'un élément atomique. Seuls les blancs entre les éléments font exception et sont ignorés. Les éléments atomiques peuvent contenir n'importe quelle séquence de zéro à plusieurs caractères Unicode. En particulier, les atomes à contenu vide sont permis et leur rendu devrait typiquement être invisible, sans chasse hormis l'espacement supplémentaire normal pour le type d'élément atomique. Les éléments vides mspace et mglyph constituent des exceptions. La largeur de l'élément mspace dépend des valeurs de ses attributs. L'élément mglyph rend le caractère décrit par ses attributs.

Quoique toutes les données textuelles Unicode soient valides en contenu des éléments atomiques, MathML 2.0 distingue un sous-ensemble particulier de caractères Unicode 3.2 nommés, appelés caractères MathML dans ce document. La liste complète des caractères MathML est définie dans le chapitre 6 Les caractères, les entités et les fontes. On peut représenter les caractères MathML directement par des données textuelles Unicode, ou bien indirectement par des références d'entité numérique ou des références d'entité de caractère. Cf. le chapitre 6 Les caractères, les entités et les fontes pour une discussion au sujet des avantages et inconvénients des références de caractères numériques opposées aux références d'entités. On peut représenter les caractères mathématiques nouveaux ou les glyphes non standards des caractères MathML existants au moyen de l'élément mglyph.

Hormis l'élément mglyph, l'élément malignmark est le seul autre élément admis en contenu des atomes. Cf. la section 3.5.5 Les marqueurs d'alignement pour des précisions.

Les éléments atomiques (à part mspace et mglyph) devraient être rendus par leur contenu (c'est-à-dire, dans le cas d'un rendu visuel, comme une rangée horizontale formée des glyphes standards des caractères de leur contenu, espacés au plus près). Les algorithmes de rendu devraient aussi prendre en compte les attributs de style mathématique, dont la description suit, et modifier l'espacement autour selon les règles ou les attributs spécifiques de chaque type d'élément atomique.

3.2.1.1 Les caractères symboliques alphanumériques

Une grande partie des symboles mathématiques se compose d'identificateurs d'une seule lettre, habituellement utilisés comme noms de variable dans les formules. Les différentes variantes de police d'une lettre sont traitées comme des symboles distincts. Par exemple, un g gothique peut indiquer une algèbre de Lie, tandis qu'un g romain indique le groupe de Lie correspondant. Ces symboles pareils à des lettres ont traditionnellement une composition qui se différencie des mêmes caractères apparaissant dans un texte par des conventions d'espacement et de ligature différentes. Ces caractères doivent également être traités de façon particulière par les mécanismes de style, car les transformations de style arbitraires peuvent changer la signification d'une expression.

Pour toutes ces raisons, Unicode 3.1 ajoutera plus de neuf cents caractères symboliques alphanumériques mathématiques correspondant aux symboles pareils à des lettres. Ces caractères se trouvent dans le Plan multilingue complémentaire, ou PMC (N.D.T. SMP). Cf. le chapitre 6 Les caractères, les entités et les fontes pour plus d'informations. En tant que données Unicode valides, ces caractères sont admis dans MathML 2.0 et, puisque les outils et les polices pour ces caractères sont de plus en plus répandus, nous prévoyons que ce moyen prédominera pour indiquer des symboles pareils à des lettres.

Toutefois, en attendant que la gestion des caractères du PMC soit suffisamment répandue, il est toujours nécessaire de fournir un codage de remplacement en utilisant seulement le Plan multilingue de base, ou PMB (N.D.T. BMP) avec un balisage. MathML 2.0 définit une correspondance entre les éléments atomiques avec certaines combinaisons de données textuelles PMB et l'attribut mathvariant, et les atomes contenant des caractères symboliques alphanumériques mathématiques du PMC. Les applications de traitement acceptant les caractères du PMC sont tenues de traiter les combinaisons de caractères et d'attributs PMB correspondantes de façon identique. La section suivante discute plus en détails de l'attribut mathvariant, et une description technique complète des caractères correspondants est donnée dans la section 6.2.3 Les caractères symboliques alphanumériques mathématiques.

3.2.2 Les attributs de style mathématique communs des éléments atomiques

MathML 2.0 introduit quatre nouveaux attributs de style mathématique. Ces attributs sont valides sur tous les éléments atomiques de présentation, sauf les éléments mspace et mglyph, et sur aucun autre élément hormis mstyle. Ces attributs sont les suivants :

Nom Valeurs Valeur par défaut
mathvariant normal | bold | italic | bold-italic | double-struck | bold-fraktur | script | bold-script | fraktur | sans-serif | bold-sans-serif | sans-serif-italic | sans-serif-bold-italic | monospace normal (sauf sur <mi>)
mathsize small | normal | big | number v-unit héritée
mathcolor #rgb | #rrggbb | html-color-name héritée
mathbackground #rgb | #rrggbb | html-color-name héritée

Cf. la section 2.4.4 Les valeurs des attributs MathML concernant la terminologie et la notation employées pour les descriptions des valeurs d'attributs.

Les attributs de style mathématique définissent des classes logiques d'éléments atomiques. Chaque classe est conçue pour correspondre à une collection d'atomes symboliques, reliés typographiquement, qui possèdent une signification dans une expression mathématique donnée et nécessitent donc d'être distingués visuellement et protégés vis-à-vis des changements involontaires de style à l'échelle du document qui pourraient changer leur signification.

Quand le rendu MathML a lieu dans un environnement disposant de CSS, on peut assimiler les attributs de style mathématique à des sélecteurs prédéfinis pour les règles de style CSS. Cf. la section 7.1.5 L'utilisation de CSS avec MathML et l'Annexe G Exemple de feuille de style CSS pour MathML pour des précisions et un exemple de feuille de style CSS. Si CSS n'est pas disponible, la distinction visuelle des différentes classes logiques revient au mécanisme de style interne de l'application de rendu.

Sur un plan théorique, les moteurs de rendu ont toute liberté pour faire correspondre les attributs de style mathématique aux propriétés de rendu spécifiques. Toutefois, dans la pratique, les noms et valeurs des attributs de style mathématique suggèrent des propriétés typographiques évidentes et les moteurs de rendu devraient essayer de respecter ces interprétations naturelles autant que possible. Par exemple, on peut raisonnablement rendre un atome avec l'attribut mathvariant réglé à sans-serif dans la police Helvetica ou Arial. Par contre, on devrait éviter de rendre cet atome dans la police Times Roman car les conséquences à l'interprétation pourraient êtres graves.

Un problème se pose lorsque les interprétations naturelles des valeurs de l'attribut mathvariant ne sont logiques que pour certains caractères. Par exemple, le rendu d'un caractère alphabétique gothique (N.d.T. fraktur) ne se distingue pas nettement de celui d'un caractère Kanji "bold-italic". En général, les seuls cas où l'interprétation est claire sont exactement ceux correspondant aux caractères symboliques alphanumériques mathématiques PMC.

Par conséquent, on encourage très fortement les auteurs de feuille de style et les développeurs d'application à respecter strictement l'interprétation typographique évidente de l'attribut mathvariant quand il s'applique à des caractères ayant une contrepartie symbolique alphanumérique mathématique PMC. Dans tous les autres cas, il revient au moteur de rendu de déterminer, le cas échéant, quel effet aura l'attribut mathvariant. Par exemple, un moteur de rendu peut raisonnablement choisir d'afficher un atome contenant la référence d'entité &sum; (un caractère sans contrepartie PMC) dans une police grasse quand l'attribut mathvariant a la valeur "bold" ou "bold-fraktur", et de l'afficher dans une police romaine par défaut quand sa valeur est "fraktur". Ainsi que le montre cet exemple, les auteurs devraient éviter d'utiliser l'attribut mathvariant avec des caractères sans contreparties PMC, car leurs rendus seront peut-être inutiles ou imprévisibles.

Enfin, l'attribut mathvariant est cause d'un problème de redondance dont il faudra tenir compte comme cas particulier. Lorsqu'on utilise l'attribut mathvariant sur un élément mi contenant un seul caractère issu d'étendues spécifiques de données textuelles PMB, abordées dans la section 6.2.3 Les caractères symboliques alphanumériques mathématiques, le rendu final ne se distinguera pas visuellement de celui d'un élément mi sans attribut contenant le caractère PMC correspondant. C'est la raison pour laquelle MathML 2.0 impose aux applications de traitement de considérer ces deux représentations comme équivalentes. Cela constitue principalement un problème pour les applications permettant les recherches et/ou les tests d'égalité.

Les éléments atomiques admettent également les attributs id, xref, class et style pour la compatibilité avec les mécanismes de feuille de style, cf. la section 2.4.5 Les attributs communs à tous les éléments MathML. Néanmoins, on doit faire attention lorsqu'on utilise CSS généralement. On devrait tout particulièrement éviter de recourir à CSS pour produire des effets visuels qui altèrent la signification d'une équation, car MathML est utilisé dans beaucoup d'environnements non-CSS. De même, on devrait s'assurer que les transformations de style arbitraires à l'échelle du document n'affectent pas les expressions mathématiques au point d'en altérer la signification.

Puisque les expressions MathML sont souvent imbriquées dans un format textuel de données tel que XHTML, le texte alentour et le code MathML devront partager des attributs de rendu telle que la taille de la police, de sorte que le style des rendus soit compatible. Pour cette raison, les valeurs d'attributs agissant sur le rendu du texte sont, pour la plupart, héritées de l'environnement de rendu, comme l'indique la colonne Défaut du tableau précédent. (Dans les cas où le texte alentour et le code MathML sont rendus par des logiciels séparés, par exemple, par un navigateur et un module d'extension, il importe également que l'environnement de rendu fournisse au moteur de rendu MathML des informations supplémentaires, telle que la position de la ligne de base du texte alentour, qui ne sont pas définies par les attributs MathML). Toutefois, remarquez que MathML 2.0 ne définit pas de mécanisme selon lequel les informations de style sont héritées de l'environnement de rendu. Par exemple, un module d'extension de navigateur comptera peut-être entièrement sur le mécanisme d'héritage CSS et utilisera les propriétés CSS totalement résolues pour le rendu, tandis qu'une autre application consultera peut-être uniquement l'environnement de style au nœud racine puis utilisera ses propres règles internes d'héritage de style.

Pour la plupart, les moteurs de rendu MathML compteront probablement, à des degrés divers, sur d'autres algorithmes de traitement de style internes. En particulier, l'héritage de l'attribut mathvariant ne suit pas le modèle CSS. La valeur par défaut de cet attribut est "normal" (non italique) pour tous les atomes sauf pour mi. Pour les atomes mi, la valeur par défaut dépend du nombre de caractères du contenu de l'atome. (L'attribut à éviter fontslant a également ce comportement). Cf. la section 3.2.3 L'identifiant (mi) pour des précisions.

3.2.2.1 Les attributs de style à éviter sur les éléments atomiques

Les attributs de style MathML 1.01 listés ci-dessous sont à éviter dans MathML 2.0. Dans les environnements de rendu gérant CSS, il est préférable d'utiliser CSS pour contrôler les propriétés de rendu correspondant à ces attributs. Néanmoins, comme expliqué précédemment, on devrait généralement éviter de manipuler directement ces propriétés de rendu, quel que soit le moyen.

Si un nouvel attribut de style mathématique et des attributs à éviter conflictuels sont donnés simultanément, on devrait utiliser la nouvelle valeur d'attribut de style mathématique. Par exemple :

<mi fontweight='bold' mathvariant='normal'> a </mi>

Ce rendu-ci devrait se faire dans une police de graisse normale, et :

<mi fontweight='bold' mathvariant='sans-serif'> a </mi>

Ce rendu-là devrait se faire dans une police de graisse normale sans empattement. Dans l'exemple suivant :

<mi fontweight='bold' mathvariant='fraktur'> a1 </mi>

L'attribut mathvariant prime encore sur l'attribut fontweight, même si on ne devrait pas en général appliquer la valeur "fraktur" à un 1, puisqu'il n'y a aucun caractère symbolique alphanumérique mathématique PMC correspondant. En absence d'une police contenant des chiffres gothiques, la plupart des moteurs de rendu rendra probablement l'expression par un a gothique suivi d'un 1 romain.

Les nouveaux attributs de style mathématique priment aussi sur les valeurs des attributs de style à éviter héritées de MathML 1.01. Ainsi :

<mstyle fontstyle='italic'>
  <mi mathvariant='bold'> a </mi>
</mstyle>

Le rendu a lieu dans une police grasse droite et non dans une police grasse italique.

En même temps, les attributs MathML 1.01 ont encore un usage. Puisqu'ils correspondent directement aux propriétés de rendu nécessaires pour la disposition mathématique, ils sont très utiles pour décrire les règles et les algorithmes de disposition de MathML. Pour cette raison et pour la rétrocompatibilité, on continue de décrire les règles de rendu MathML suggérées dans ce chapitre dans les termes des propriétés de rendu décrites par ces attributs de style MathML 1.01.

Les attributs à éviter sont les suivants :

Nom Valeurs Valeur par défaut
fontsize number v-unit héritée
fontweight normal | bold héritée
fontstyle normal | italic normal (sauf sur <mi>)
fontfamily string | css-fontfamily héritée
color #rgb | #rrggbb | html-color-name héritée

L'attribut fontsize définit la taille de police voulue. La valeur v-unit représente une unité de longueur verticale (cf. la section 2.4.4.3 Les attributs compatibles avec CSS). L'unité la plus commune pour indiquer une taille de police dans une composition est le point pt.

Si la taille requise pour la police courante n'est pas disponible, le moteur de rendu devrait en faire une approximation de façon à obtenir le rendu en haute qualité le plus intelligible.

Beaucoup d'éléments MathML changent automatiquement la valeur de l'attribut fontsize chez certains de leurs enfants ; cf. la discussion à propos de l'attribut scriptlevel dans la section 3.3.4 Les changements de style (mstyle).

La valeur de l'attribut fontfamily devrait être le nom d'une police susceptible d'être disponible pour le moteur de rendu MathML, ou une information lui permettant de sélectionner une police d'une façon ou d'une autre ; les valeurs acceptables et leurs significations dépendent du moteur de rendu spécifique et de l'environnement de rendu utilisé, et elles ne sont pas définies par MathML (mais voir la remarque à suivre à propos de css-fontfamily). (Remarquez que le mécanisme du moteur de rendu pour récupérer des polices par leur nom peut être sensible à la casse).

Si la valeur de fontfamily n'est pas reconnue par un moteur de rendu MathML particulier, on ne devrait jamais considérer cela comme une condition d'erreur MathML ; le moteur de rendu devrait plutôt utiliser une police qui puisse représenter, de son point de vue, un substitut convenable de la police demandée, ou bien ignorer l'attribut et agir comme si aucune valeur n'avait été fournie.

Remarquez que l'utilisation de l'attribut fontfamily ne sera vraisemblablement pas portable d'un moteur de rendu MathML à l'autre. Notamment, on ne devrait jamais s'en servir pour essayer de reproduire l'effet d'un appel de caractère MathML non-ASCII (par exemple, en appelant un caractère d'une certaine police de symboles qui fait correspondre des caractères ordinaires à des glyphes de caractères non-ASCII). En corollaire de ce principe, les moteurs de rendu MathML devraient essayer de toujours produire des rendus intelligibles des caractères MathML listés dans le chapitre 6 Les caractères, les entités et les fontes, même lorsque ces caractères ne sont pas disponibles dans la famille de polices indiquée. Un tel rendu est toujours possible : en dernier recours, on peut rendre un caractère qui apparaît comme une référence d'entité de type XML en recourant à l'un des noms d'entité donnés pour le caractère en question dans le chapitre 6 Les caractères, les entités et les fontes.

La variable css-fontfamily se rapporte à une valeur légale de la propriété font-family de CSS, qui est une liste de noms de famille de polices, ou de types de police générique, séparés par des virgules, en ordre de préférence décroissante, comme cela est documenté en détails dans CSS [CSS2]. On encourage les moteurs de rendu MathML à adopter la syntaxe CSS pour indiquer les polices quand leur environnement de rendu le permet, même si par ailleurs ils ne gèrent pas CSS. (Cf. également la sous-section à propos des attributs compatibles avec CSS dans la section 2.4.4.3 Les attributs compatibles avec CSS).

3.2.2.2 Les attributs liés à la couleur

L'attribut mathcolor (et celui à éviter color) contrôle la couleur dans laquelle le contenu des atomes est rendu. En outre, hérité d'un élément mstyle ou de l'environnement de rendu d'une expression MathML, il contrôle la couleur de tous les autres dessins des éléments MathML, y compris les lignes ou les signes de radical susceptibles d'être dessinés par les éléments mfrac, mtable ou msqrt.

On peut définir les valeurs des attributs mathcolor, color, mathbackground et background comme une chaîne composée d'un caractère # suivi, sans espace intermédiaire, par les valeurs hexadécimales à un chiffre, ou bien à deux chiffres, des composantes rouge, vert et bleu, respectivement, de la couleur voulue, en utilisant le même nombre de chiffres pour chaque composante (ou encore par le mot-clé "transparent" dans le cas de l'attribut background). Les chiffres hexadécimaux sont insensibles à la casse. Les valeurs possibles à un chiffre s'étendent de 0 (composante absente) à F (composante entièrement présente) et à deux chiffres de 00 (composante absente) à FF (composante entièrement présente), la valeur à un chiffre x équivalant celle à deux chiffres xx (au lieu de x0). La notation x0 serait plus correcte strictement mais rendrait de façon désastreuse dans certains navigateurs.

On peut aussi fixer ces attributs avec un type de valeur html-color-name, dont la définition suit.

La syntaxe de couleur décrite précédemment constitue un sous-ensemble de la syntaxe des propriétés CSS color et background-color. La syntaxe de background-color constitue à son tour un sous-ensemble de la syntaxe complète de la propriété CSS background, qui permet également de définir, par exemple, une image de fond et sa répétition optionnelle. On utilise le nom d'attribut plus général background dans MathML pour faciliter les extensions éventuelles de la portée de l'attribut dans les futures versions de MathML.

On peut aussi définir les valeurs de couleur de l'un ou l'autre attribut comme valeur html-color-name, c'est-à-dire, en employant l'un des mots-clés de nom de couleur définis dans [HTML4] (aqua, black, blue, fuchsia, gray, green, lime, maroon, navy, olive, purple, red, silver, teal, white et yellow). Remarquez que les mots-clés de nom de couleur sont insensibles à la casse, contrairement à la plupart des mots-clés des valeurs d'attribut MathML, pour compatibilité avec CSS et HTML.

Les règles suggérées du rendu visuel MathML ne définissent pas l'étendue exacte des régions dont l'arrière-plan est affecté par l'utilisation de l'attribut background sur l'élément mstyle, hormis la chose suivante : lorsque le contenu de l'élément mstyle n'a aucune dimension négative et que la région occupée par son dessin n'est pas recouverte par un autre dessin à cause d'un espacement environnant négatif, alors cette région devrait s'étendre derrière la totalité du dessin qui rend le contenu de l'élément mstyle mais elle ne devrait pas s'étendre derrière le dessin de rendu d'une expression environnante. Ces règles ne définissent pas l'effet de recouvrement du dessin des régions provoqué par un espacement négatif sur l'étendue de la région affectée par l'attribut background.

3.2.3 Les identificateurs (mi)

3.2.3.1 Description

Un élément mi représente un nom symbolique, ou un texte arbitraire, qui devrait être rendu comme un identificateur. Les identificateurs comprennent les variables, les noms de fonction et les constantes symboliques.

Les identificateurs mathématiques ne sont pas tous représentés par des éléments mi, par exemple, on devrait représenter les variables écrites en indice ou en exposant en se servant, respectivement, des éléments msub ou msup. Réciproquement, on peut représenter un texte arbitraire jouant le rôle d'un terme (telle qu'une ellipse dans une série additionnée) en se servant d'un élément mi, comme illustré par un exemple de la section 3.2.6.4 Le mélange du texte et des mathématiques.

Rappelons que mi est un élément de présentation et, à ce titre, il indique seulement que son contenu devrait être rendu comme un identificateur. Dans la majorité des cas, le contenu d'un élément mi représentera effectivement un identificateur mathématique, tels qu'une variable ou un nom de fonction. Toutefois, comme indiqué au paragraphe précédent, la correspondance entre les notations à rendre comme des identificateurs et les notations effectivement destinées à représenter des identificateurs mathématiques n'est pas parfaite. Pour un élément dont la sémantique est assurée d'être celle d'un identificateur, cf. la description de l'élément ci dans le chapitre 4 Le balisage de contenu.

3.2.3.2 Attributs

Les éléments mi acceptent les attributs listés dans la section 3.2.2 Les attributs de style mathématique communs des éléments atomiques mais avec une valeur d'attribut par défaut différente dans un cas :

Nom Valeurs Valeur par défaut
mathvariant normal | bold | italic | bold-italic | double-struck | bold-fraktur | script | bold-script | fraktur | sans-serif | bold-sans-serif | sans-serif-italic | sans-serif-bold-italic | monospace (selon le contenu ; description à suivre)
fontstyle (à éviter) normal | italic (selon le contenu ; description à suivre)

Un moteur de rendu graphique typique rendrait un élément mi par les caractères composant son contenu, sans espacement supplémentaire autour des caractères (hormis l'espacement associé aux éléments voisins). La valeur par défaut des attributs mathvariant et fontstyle serait (typiquement) "normal" (non italique), à moins que le contenu ne se compose que d'un seul caractère, auquel cas ce serait la valeur "italic". Remarquez que cette règle des attributs mathvariant et fontstyle est spécifique des éléments mi ; la valeur par défaut des attributs mathvariant et fontstyle sur d'autres éléments atomiques MathML est "normal".

Remarquez que, pour déterminer les équivalences des caractères symboliques alphanumériques mathématiques (cf. la section 6.2.3 Les caractères symboliques alphanumériques mathématiques et la section 3.2.1.1 Les caractères symboliques alphanumériques), on devrait résoudre la valeur de l'attribut mathvariant en premier, y compris le comportement par défaut particulier décrit précédemment.

3.2.3.3 Exemples

<mi> x </mi>
<mi> D </mi>
<mi> sin </mi>
<mi mathvariant='script'> L </mi>
<mi></mi>

Un élément mi sans contenu est permis ; un éditeur d'expressions, par exemple, pourrait utiliser le code <mi></mi> pour représenter, dans une expression MathML, la position d'un terme obligatoire (conformément à la syntaxe conventionnelle des mathématiques) mais qui n'en contient pas encore.

Les identificateurs comprennent les noms de fonction tel que sin. On devrait écrire les expressions, telle que sin x, en utilisant l'opérateur &ApplyFunction; (dont le nom abrégé est &af;) comme illustré par l'exemple suivant ; cf. également la discussion à propos des opérateurs invisibles dans la section 3.2.5 Les opérateurs, les délimiteurs, les séparateurs ou les accents (mo).

<mrow>
  <mi> sin </mi>
  <mo> &ApplyFunction; </mo>
  <mi> x </mi>
</mrow>

On peut également représenter un texte arbitraire à traiter comme un terme par un élément mi, comme suit :

<mrow>
  <mn> 1 </mn>
  <mo> + </mo>
  <mi> ... </mi>
  <mo> + </mo>
  <mi> n </mi>
</mrow>

Lorqu'on utilise un élément mi dans ces situations exceptionnelles, fixer explicitement la valeur de l'attribut fontstyle peut donner de meilleurs résultats que le comportement par défaut de certains moteurs de rendu.

On devrait représenter les noms des constantes symboliques par des éléments mi :

<mi> &pi; </mi>
<mi> &ImaginaryI; </mi>
<mi> &ExponentialE; </mi>

Utiliser des références d'entité spéciales pour ces constantes peut simplifier l'interprétation des éléments de présentation MathML. Cf. le chapitre 6 Les caractères, les entités et les fontes pour une liste complète des références d'entités de caractères dans MathML.

3.2.4 Les nombres (mn)

3.2.4.1 Description

Un élément mn représente un littéral numérique ou d'autres données à rendre comme littéral numérique. D'une manière générale, un littéral numérique est une séquence de chiffres, avec éventuellement un point décimal, représentant un entier non signé ou un nombre réel.

Le concept mathématique d'un nombre peut être assez subtil et compliqué, selon le contexte. Par conséquent, les nombres mathématiques ne devraient pas tous être représentés par des éléments mn ; les exemples suivants montre les nombres mathématiques qu'il faudrait représenter différemment, à savoir les nombres complexes, les rapports de nombres sous forme de fractions et les noms de constantes numériques.

Inversement, puisque mn est un élément de présentation, il y a quelques situations où on souhaitera inclure un texte arbitraire dans le contenu d'un élément mn à rendre simplement comme un littéral numérique, bien que l'interprétation de ce contenu comme un nombre puisse être ambiguë conformément à un codage standard particulier des nombres en tant que séquences de caractères. Toutefois, en règle générale, on devrait réserver l'élément mn aux situations où son contenu servira effectivement à représenter une quantité numérique d'une manière ou d'une autre. Pour un élément dont la sémantique est assurée d'être celle d'un type particulier de nombre mathématique, cf. la description de l'élément cn dans le chapitre 4 Le balisage de contenu.

3.2.4.2 Attributs

Les éléments mn acceptent les attributs listés dans la section 3.2.2 Les attributs de style mathématique communs des éléments atomiques.

Un moteur de rendu typique rendrait un élément mn par les caractères de son contenu, sans espacement supplémentaire autour des caractères (hormis l'espacement des éléments voisins tel que mo). À la différence de l'élément mi, les éléments mn sont (typiquement) rendus par défaut dans une police non italique, indépendamment de leur contenu.

3.2.4.3 Exemples

<mn> 2 </mn>
<mn> 0.123 </mn>
<mn> 1,000,000 </mn>
<mn> 2.1e10 </mn>
<mn> 0xFFEF </mn>
<mn> MCMLXIX </mn>
<mn> vingt-et-un </mn>

3.2.4.4 Les nombres qu'on ne devrait pas écrire seulement avec l'élément mn

Beaucoup de nombres mathématiques devraient être représentés en utilisant d'autres éléments de présentation et pas uniquement des éléments mn ; cela comprend les nombres complexes, les rapports de nombres sous forme de fractions et les noms des constantes numériques. Voici des exemples de représentation MathML pour ces nombres :

<mrow>
  <mn> 2 </mn>
  <mo> + </mo>
  <mrow>
    <mn> 3 </mn>
    <mo> &InvisibleTimes; </mo>
    <mi> &ImaginaryI; </mi>
  </mrow>
</mrow>
<mfrac> <mn> 1 </mn> <mn> 2 </mn> </mfrac>
<mi> &pi; </mi>
<mi> &ExponentialE; </mi>

3.2.5 Les opérateurs, les délimiteurs, les séparateurs ou les accents (mo)

3.2.5.1 Description

Un élément mo représente un opérateur ou tout ce qui devrait se rendre comme un opérateur. En général, les conventions de notation pour les opérateurs mathématiques sont assez compliquées, et MathML offre donc un mécanisme relativement sophistiqué pour définir le comportement de rendu d'un élément mo. Par conséquent, dans MathML, la liste des choses devant se rendre comme un opérateur comprend un certain nombre de notations qui ne sont pas des opérateurs mathématiques au sens ordinaire. Hormis les opérateurs ordinaires avec des formes infixées, préfixées ou suffixées, cette liste comprend des caractères de délimitation tels que les accolades, les parenthèses et les traits des valeurs absolues, des séparateurs tels que la virgule et le point-virgule, et des accents mathématiques tels que le trait ou le tilde sur un symbole.

Le terme opérateur tel qu'il est employé dans ce chapitre désigne tout symbole, ou notation, devant se rendre comme un opérateur, et qui est donc représentable par un élément mo. C'est-à-dire, le terme opérateur englobe tous les opérateurs ordinaires, les délimiteurs, les séparateurs et les accents, sauf indication contraire ou autre signification d'après le contexte.

Tous ces symboles sont représentés dans MathML par des éléments mo car ils sont soumis essentiellement aux mêmes attributs et règles de rendu ; le cas échéant, les distinctions subtiles du rendu de ces classes de symboles sont gérées par les attributs booléens fence, separator et accent afin de discriminer, respectivement, les délimiteurs, les séparateurs et les accents.

Une caractéristique clé de l'élément mo tient au fait que les valeurs par défaut de ses attributs sont fixées au cas-par-cas d'après un dictionnaire d'opérateurs comme expliqué ensuite. En particulier, les valeurs par défaut des attributs fence, separator et accent pourront se trouver dans le dictionnaire d'opérateurs et n'auront pas besoin d'être indiquées sur chaque élément mo.

Remarquez que certains opérateurs mathématiques ne sont pas représentés par des éléments mo seuls mais par des éléments mo embellis, par exemple, avec des exposants environnants ; cf. les précisions qui suivent. Inversement, en tant qu'éléments de présentation, les éléments mo peuvent contenir un texte arbitraire, même quand ce texte n'est pas censé être interprété comme un opérateur ; cf., par exemple, la discussion intitulée Le mélange du texte et des mathématiques dans la section 3.2.6 Le texte (mtext). Cf. également le chapitre 4 Le balisage de contenu pour les définitions des éléments de contenu MathML assurés d'avoir une sémantique d'opérateur mathématique spécifique.

3.2.5.2 Attributs

Les éléments mo acceptent les attributs listés dans la section 3.2.2 Les attributs de style mathématique communs des éléments atomiques et les autres attributs listés ici. Pour la plupart, les attributs obtiennent leurs valeurs par défaut auprès du dictionnaire, cf. la section 3.2.5.7.1 Le dictionnaire d'opérateurs dont la description suit dans cette section. Si le dictionnaire ne contient aucune entrée pour un élément mo donné, c'est la valeur par défaut donnée ici entre parenthèses qui sera utilisée.

Nom Valeurs Valeur par défaut
form prefix | infix | postfix fixée selon la position de l'opérateur dans un élément mrow (la règle suit) ; utilisée avec le contenu d'un élément mo pour indexer le dictionnaire d'opérateurs
fence true | false fixée par le dictionnaire (false)
separator true | false fixée par le dictionnaire (false)
lspace number h-unit | namedspace fixée par le dictionnaire (thickmathspace)
rspace number h-unit | namedspace fixée par le dictionnaire (thickmathspace)
stretchy true | false fixée par le dictionnaire (false)
symmetric true | false fixée par le dictionnaire (true)
maxsize number [ v-unit | h-unit ] | namedspace | infinity fixée par le dictionnaire (infinity)
minsize number [ v-unit | h-unit ] | namedspace fixée par le dictionnaire (1)
largeop true | false fixée par le dictionnaire (false)
movablelimits true | false fixée par le dictionnaire (false)
accent true | false fixée par le dictionnaire (false)

La valeur h-unit représente une unité de longueur horizontale et la valeur v-unit une unité de longueur verticale (cf. la section 2.4.4.2 Les attributs avec des unités). Le type namedspace prend l'une des valeurs suivantes : "negativeveryverythinmathspace", "negativeverythinmathspace", "negativethinmathspace", "negativemediummathspace", "negativethickmathspace", "negativeverythickmathspace", "negativeveryverythickmathspace", "veryverythinmathspace", "verythinmathspace", "thinmathspace", "mediummathspace", "thickmathspace", "verythickmathspace" ou "veryverythickmathspace". On peut fixer ces valeurs en se servant de l'élément mstyle, comme cela est précisé dans la section 3.3.4 Les changements de style (mstyle).

Si aucune unité n'est fournie avec les valeurs des attributs maxsize ou minsize, ce nombre est un multiplicateur de la taille normale de l'opérateur dans la direction (ou les directions) où il s'étire. D'autres explications à propos de ces attributs sont fournies après.

Les moteurs de rendu graphiques typiques rendent tous les éléments mo par les caractères composant leurs contenus, avec un espacement supplémentaire autour de l'élément déterminé d'après les attributs listés précédemment. Les règles précises pour déterminer l'espacement de l'opérateur dans les rendus visuels sont décrites dans une sous-section suivante. Comme toujours, MathML n'impose aucun rendu spécifique et ces règles sont des suggestions pratiques aux développeurs.

Les moteurs de rendu ne disposant pas de polices complètes pour le jeu de caractères MathML peuvent, dans certains cas, choisir de ne pas rendre un élément mo par les caractères exacts de son contenu. Par exemple, il pourrait rendre l'expression <mo> &le; </mo> par  <=  dans un terminal. Toutefois, en règle générale, les moteurs de rendu devraient essayer de rendre le contenu d'un élément mo aussi littéralement que possible. Il faudrait donc rendre différemment les expressions <mo> &le; </mo> et <mo> &lt;= </mo> (la première par un seul caractère, c.à.d. le signe inférieur à égal à, et la seconde par la séquence de deux caractères <=).

3.2.5.3 Exemples avec des opérateurs ordinaires

<mo> + </mo>
<mo> &lt; </mo>
<mo> &le; </mo>
<mo> &lt;= </mo>
<mo> ++ </mo>
<mo> &sum; </mo>
<mo> .NOT. </mo>
<mo> and </mo>
<mo> &InvisibleTimes; </mo>
<mo mathvariant='bold'> + </mo>

3.2.5.4 Exemples avec des délimiteurs et des séparateurs

Remarquez que les éléments mo dans ces exemples ne nécessitent pas d'attributs fence ou separator explicites puisqu'on peut les obtenir auprès du dictionnaire d'opérateurs (dont la description suit). On pourrait également coder certains de ces exemples à l'aide de l'élément mfenced, cf. la section 3.3.8 Les expressions comprises entre une paire de délimiteurs (mfenced).

(a+b)

<mrow>
  <mo> ( </mo>
  <mrow>
    <mi> a </mi>
    <mo> + </mo>
    <mi> b </mi>
  </mrow>
  <mo> ) </mo>
</mrow>

[0,1)

<mrow>
  <mo> [ </mo>
  <mrow>
    <mn> 0 </mn>
    <mo> , </mo>
    <mn> 1 </mn>
  </mrow>
  <mo> ) </mo>
</mrow>

f(x,y)

<mrow>
  <mi> f </mi>
  <mo> &ApplyFunction; </mo>
  <mrow>
    <mo> ( </mo>
    <mrow>
      <mi> x </mi>
      <mo> , </mo>
      <mi> y </mi>
    </mrow>
    <mo> ) </mo>
  </mrow>
</mrow>

3.2.5.5 Les opérateurs invisibles

Certains opérateurs, invisibles dans la notation mathématique traditionnelle, devraient être représentés par des références d'entités spécifiques dans les éléments mo, et non par rien. Les références d'entités utilisées pour ces opérateurs invisibles sont les suivantes :

Nom entier Nom abrégé Exemples d'utilisation
&InvisibleTimes; &it; xy
&ApplyFunction; &af; f(x) sin x
&InvisibleComma; &ic; m12

Les représentations MathML des exemples du tableau précédent sont les suivantes :

<mrow>
  <mi> x </mi>
  <mo> &InvisibleTimes; </mo>
  <mi> y </mi>
</mrow>

<mrow>
  <mi> f </mi>
  <mo> &ApplyFunction; </mo>
  <mrow>
    <mo> ( </mo>
    <mi> x </mi>
    <mo> ) </mo>
  </mrow>
</mrow>

<mrow>
  <mi> sin </mi>
  <mo> &ApplyFunction; </mo>
  <mi> x </mi>
</mrow>

<msub>
  <mi> m </mi>
  <mrow>
    <mn> 1 </mn>
    <mo> &InvisibleComma; </mo>
    <mn> 2 </mn>
  </mrow>
</msub>

Les raisons pour lesquelles on utilise des éléments mo spécifiques pour les opérateurs invisibles sont les suivantes :

Par exemple, un moteur de rendu sonore pourrait rendre l'expression f(x) (comme dans l'exemple précédent) en disant f de x mais pourrait employer fois pour rendre xy. Bien que le rendu doive toujours être différent en fonction de la structure des éléments voisins (parfois en omettant complètement le de ou le fois), la tâche du moteur de rendu sera beaucoup plus facile avec un élément mo différent pour chaque opérateur invisible.

3.2.5.6 Les noms des autres opérateurs spéciaux

MathML inclut aussi l'entité &DifferentialD; qui, dans un élément mo, sert à représenter l'opérateur différentiel indiqué habituellement par d. Les raisons d'utiliser explicitement cette entité spéciale sont similaires à celles pour les entités spéciales des opérateurs invisibles décrits dans la section précédente.

3.2.5.7 Le détail des règles de rendu des éléments mo

Les comportements typiques du rendu visuel des éléments mo étant plus complexes que ceux des autres éléments atomiques MathML, leurs règles de rendu sont donc décrites dans cette sous-section distincte.

Remarquez, comme pour toutes les règles de rendu MathML, que celles-ci sont des suggestions et non des obligations. En outre, on n'essaye pas de définir entièrement le rendu mais plutôt de donner suffisamment d'informations afin que l'effet attendu pour les divers attributs de rendu soit aussi clair que possible.

Le dictionnaire d'opérateurs

Beaucoup de symboles mathématiques, tels que le signe de l'intégrale, le signe plus ou les parenthèses, ont un emploi bien établi, prévisible et traditionnel dans la notation. En général, cette utilisation se résume à certaines valeurs d'attribut par défaut d'éléments mo avec des contenus spécifiques et avec un attribut form spécifique. Puisque ces valeurs par défaut varient d'un symbole à l'autre, MathML prévoit que les moteurs de rendu auront un dictionnaire d'opérateurs pour les attributs par défaut des éléments mo (cf. l'Annexe F Le dictionnaire d'opérateurs) indexé par le contenu et l'attribut form de chaque élément mo. Si un élément mo n'est pas listé dans le dictionnaire, on devrait utiliser les valeurs par défaut du tableau des attributs des éléments mo, données entre parenthèses, puisque ces valeurs sont typiquement acceptables pour un opérateur générique.

Certains opérateurs sont surchargés, au sens où ils peuvent apparaître en plusieurs formes (préfixée, infixée ou suffixée), avec éventuellement des propriétés de rendu différentes pour chaque forme. Par exemple, le caractère + peut être un opérateur préfixe ou bien infixe. Un moteur de rendu visuel ajoutera typiquement un espace de chaque côté d'un opérateur infixe, tandis qu'il en ajoutera seulement à gauche d'un opérateur préfixe. L'attribut form permet d'indiquer quelle forme utiliser si plusieurs formes étaient possibles d'après le dictionnaire d'opérateurs et si la valeur par défaut décrite précédemment ne convenait pas.

La valeur par défaut de l'attribut form

Il n'est habituellement pas nécessaire de définir explicitement l'attribut form, puisqu'il existe des règles heuristiques efficaces permettant d'en déduire la valeur d'après le contexte. S'il n'est pas indiqué et que plusieurs formes sont possibles dans le dictionnaire d'un élément mo avec un contenu donné, le moteur de rendu devra choisir la forme à utiliser selon les règles suivantes (mais voir l'exception des opérateurs embellis décrite ensuite) :

Remarquez que ces règles se rapportent à l'élément mrow où se trouve l'élément mo. Dans certaines situations, cet élément mrow sera peut-être un mrow implicite présent autour des arguments d'un élément tel que msqrt ou mtd.

Les délimiteurs ouvrants (à gauche) devraient être définis par form="prefix" et les délimiteurs fermant (à droite) par form="postfix" ; les séparateurs sont habituellement infixés, mais pas toujours, selon leur entourage. Comme pour les opérateurs ordinaires, ces valeurs ne nécessitent habituellement pas de définition explicite.

Si l'opérateur n'apparaît pas dans le dictionnaire avec la forme indiquée, le moteur de rendu devrait utiliser l'une des formes qui y sont disponibles, dans l'ordre de préférence suivant : forme infixée, forme suffixée et forme préfixée ; si aucune forme n'est disponible pour le contenu de l'élément mo en question, le moteur de rendu devrait utiliser les valeurs par défaut données entre parenthèses dans le tableau des attributs des éléments mo.

L'exception des opérateurs embellis

Il existe une exception aux règles précédentes pour choisir la valeur par défaut de l'attribut form d'un élément mo. Un élément mo qui est embelli par un ou plusieurs éléments imbriqués, des exposants, des indices, du texte ou des blancs environnants, ou par des changements de style se comporte différemment. C'est la position de l'opérateur embelli en entier (cf. la définition précise suivante) dans un élément mrow qui est examinée selon les règles précédentes et son espacement environnant qui est affecté par sa forme, et non l'élément mo nucléaire ; par contre, les attributs qui influencent l'espacement environnant proviennent de l'élément mo nucléaire (ou de l'entrée de dictionnaire de cet élément).

Par exemple, on devrait considérer la partie +4 dans l'expression a+4b comme un opérateur infixe dans son entier, du fait de sa position au milieu d'un élément mrow, mais ses attributs de rendu devraient provenir de l'élément mo représentant le caractère + ou, s'ils ne sont pas explicites, de l'entrée du dictionnaire d'opérateurs de <mo form="infix"> + </mo>. La définition exacte d'un opérateur embelli est l'une des suivantes :

Remarquez que cette définition permet l'embellissement imbriqué seulement s'il n'y a aucun élément englobant intermédiaire hormis ceux de la liste précédente.

Les règles précédentes pour choisir les formes des opérateurs et pour définir les opérateurs embellis ont été établies afin que l'auteur n'ait pas besoin de définir un attribut form dans tous les cas ordinaires.

Les justifications des définitions des opérateurs embellis

Les remarques suivantes sont incluses pour justifier certains aspects des définitions précédentes mais elles ne devraient pas avoir d'importance pour la majorité des utilisateurs de MathML.

Un élément mfrac inclus fait office d'embellisseur dans le cadre de la notation commune pour un opérateur différentiel :

<mfrac>
  <mo> &DifferentialD; </mo>
  <mrow>
    <mo> &DifferentialD; </mo>
    <mi> x </mi>
  </mrow>
</mfrac>

Puisque la définition d'un opérateur embelli influence l'utilisation des attributs lié à l'étirement, il est important qu'elle inclut les délimiteurs embellis ainsi que les opérateurs ordinaires ; elle s'applique donc à tous les élément mo.

Remarquez qu'un élément mrow avec un seul argument est un opérateur embelli si, et seulement si, son argument est un opérateur embelli. C'est parce qu'un élément mrow avec un seul argument doit être équivalent en tous points à cet argument seul (comme cela est expliqué dans la section 3.3.1 Le regroupement horizontal des sous-expressions (mrow)). Un élément mo qui est le seul argument d'un élément mrow déterminera la valeur par défaut de son attribut form par rapport à la position de cet élément mrow, le cas échéant, dans un élément mrow environnant (peut-être inféré), plutôt que par rapport à sa propre position dans l'élément mrow dont c'est le seul argument.

Remarquez que, dans la définition précédente, chaque élément mo est défini comme embelli, c'est-à-dire qu'on peut assimiler (et mettre en œuvre dans les moteurs de rendu) un opérateur embelli à une classe spéciale d'expressions MathML, dont l'élément mo représente un cas particulier.

L'espacement autour d'un opérateur

On peut indiquer directement la quantité d'espace à ajouter autour d'un opérateur (ou d'un opérateur embelli) lorsqu'il apparaît dans un élément mrow avec les attributs lspace et rspace. Ces valeurs sont exprimées en em si aucune unité n'est fournie. Par convention, les opérateurs qui tendent à une association étroite avec leurs arguments ont des valeurs d'espacement plus petites que les opérateurs qui tendent à une association moindre. Le dictionnaire d'opérateurs intégré à un moteur de rendu MathML devrait suivre cette convention. En TEX, il n'y a que les trois valeurs typiques suivantes : 3/18em, 4/18em et 5/18em. MathML n'impose pas ces limites.

Certains moteurs de rendu pourront choisir de n'utiliser aucun espacement autour de la plupart des opérateurs apparaissant en indice ou en exposant, comme dans TEX.

Les moteurs de rendu non graphiques devraient traiter de façon analogue les attributs d'espacement et les autres attributs de rendu décrits ici pour leur médium de rendu. Par exemple, un plus grand espacement pourrait se traduire par une pause plus longue dans un rendu sonore.

3.2.5.8 L'étirement des opérateurs, des délimiteurs et des accents

Quatre attributs déterminent si et comment un opérateur (peut-être embelli) s'étire afin de correspondre à la taille des autres éléments : stretchy, symmetric, maxsize et minsize. Si un opérateur a un attribut tel que stretchy="true", alors celui-ci (c'est-à-dire, chaque caractère de son contenu) obéit aux règles d'étirement listées après, en fonction des contraintes imposées par les polices et par le système de rendu des polices. En pratique, un moteur de rendu typique sera seulement capable d'étirer un jeu réduit de caractères et pourra, très probablement, seulement générer un jeu discret des corps de caractère.

Il n'y a aucune disposition, dans MathML, permettant d'indiquer dans quelle direction (horizontale ou verticale) étirer un caractère particulier, ou un opérateur ; mieux, pour stretchy="true", il devrait être étiré dans chaque direction où l'étirement est possible. (Les moteurs de rendu typiques peuvent étirer la plupart des caractères dans une diretion au plus mais quelques-uns peuvent étirer certains caractères, telles que les flèches diagonales, indépendamment dans les deux directions).

Les attributs minsize et maxsize limitent l'ampleur de l'étirement (dans l'une ou l'autre direction). Ces deux attributs se présentent comme des multiplicateurs de la dimension normale de l'opérateur dans la direction (ou les directions) d'étirement, ou comme des dimensions absolues lorsque leurs valeurs ont des unités. Par exemple, si un caractère a un attribut telq que maxsize="3", alors il peut croître jusqu'à trois fois au plus sa dimension normale (non étirée).

L'attribut symmetric détermine si la hauteur et la profondeur, au-dessus et en-dessous de l'axe du caractère, doivent être égales (par un forçage de la hauteur ou de la profondeur au maximum des deux). Par exemple, une situation où on pourrait fixer symmetric="false" est celle de parenthèses autour d'une matrice non alignée sur l'axe, ce qui se produit fréquemment lorsqu'on multiplie des matrices non carrées. Auquel cas, on veut que les parenthèses s'étirent afin de couvrir la matrice, alors qu'un étirement symétrique aurait forcé les parenthèses à dépasser sur un bord de la matrice. L'attribut symmetric ne s'applique qu'aux caractères étirables verticalement (sinon il est ignoré).

Si un élément mo étirable est embelli (comme défini précédemment dans cette section), l'élément mo nucléaire s'étire jusqu'à une dimension déterminée par le contexte de l'opérateur embelli dans son entier, c'est-à-dire, à la même dimension que si les embellissements étaient absents. Par exemple (cf. ci-dessous), les parenthèses (qui seraient typiquement réglées comme étant étirables par le dictionnaire d'opérateurs) seront l'une et l'autre étirées jusqu'à une dimension identique, la même qu'elles auraient eu sans le trait en-dessous et le trait au-dessus d'elles, et elles couvriront en plus le même intervalle vertical :

<mrow>
  <munder>
    <mo> ( </mo>
    <mo> &UnderBar; </mo>
  </munder>
  <mfrac>
    <mi> a </mi>
    <mi> b </mi>
  </mfrac>
  <mover>
    <mo> ) </mo>
    <mo> &OverBar; </mo>
  </mover>
</mrow>

Remarquez que cela signifie que les règles d'étirement, données après, se rapportent au contexte de l'opérateur embelli dans son entier, et pas uniquement à l'élément mo.

Exemple d'attributs étirables

Voici une façon de régler la dimension maximale d'une parenthèse afin qu'elle ne grandisse pas même pour une valeur par défaut stretchy="true".

<mrow>
  <mo maxsize="1"> ( </mo>
  <mfrac>
    <mi> a </mi> <mi> b </mi>
  </mfrac>
  <mo maxsize="1"> ) </mo>
</mrow>

Cet exemple devrait se rendre par (\frac{a}{b}) par opposition au rendu par défaut \left(\frac{a}{b}\right).

Remarquez que chaque parenthèse est dimensionnée indépendamment ; si l'une seulement avait maxsize="1", leurs dimensions rendues seraient différentes.

Les règles d'étirement vertical

Pour la plupart, les délimiteurs ouvrants et fermants communs sont définis, dans le dictionnaire d'opérateurs, pour s'étirer verticalement par défaut. Les opérateurs &sum;, &int;, / et les flèches verticales s'étirent aussi verticalement par défaut.

Dans le cas d'un opérateur étirable dans une cellule de table (c.à.d., dans un élément mtd), les règles précédentes supposent que chaque cellule de la rangée de table contenant l'opérateur étirable couvre exactement une rangée. (De manière équivalente, l'attribut rowspan est censé avoir la valeur "1" pour toutes les cellules dans la rangée de table, y compris la cellule contenant l'opérateur). Quand ce n'est pas le cas, l'opérateur devrait seulement s'étirer verticalement pour couvrir les cellules de table qui sont entièrement dans l'ensemble de rangées de table que couvre la cellule de l'opérateur. Les cellules de table qui s'étendent dans des rangées non couvertes par la cellule de l'opérateur étirable devraient être ignorées. Cf. la section 3.5.4.2 Attributs pour des précisions à propos de l'attribut rowspan.

Les règles d'étirement horizontal

Pour la plupart, les flèches horizontales et quelques accents s'étirent horizontalement par défaut.

Dans le cas d'un opérateur dans une cellule de table (c.à.d., dans un élément mtd), les règles précédentes supposent que chaque cellule de la colonne de table contenant l'opérateur étirable couvre exactement une colonne. (De manière équivalente, l'attribut columnspan est censé avoir la valeur "1" pour toutes les cellules de table dans la rangée de table, y compris la cellule contenant l'opérateur). Quand ce n'est pas le cas, l'opérateur devrait seulement s'étirer horizontalement pour couvrir les cellules de la table qui sont entièrement dans l'ensemble des colonnes de table que couvre la cellule de l'opérateur. Les cellules de table qui s'étendent dans des colonnes non couvertes par la cellule de l'opérateur étirable devraient être ignorées. Cf. la section 3.5.4.2 Attributs pour des précisions à propos de l'attribut rowspan.

Les règles d'étirement horizontal s'appliquent aux éléments mtd afin de permettre aux flèches de s'étirer dans les diagrammes commutatifs disposés à l'aide d'un élément mtable. Les règles d'étirement horizontal incluent les écritures pour que les exemples comme le suivant puissent fonctionner :

<mrow>
  <mi> x </mi>
  <munder>
    <mo> &RightArrow; </mo>
    <mtext> s'applique à </mtext>
  </munder>
  <mi> y </mi>
</mrow>

Cet exemple s'affichera par : x \widearrow{\mathrm{maps~to}} y.

Les règles communes de l'étirement vertical et de l'étirement horizontal

Lorsqu'un opérateur étirable n'est pas obligé de s'étirer (c'est-à-dire, s'il ne se trouve pas à l'une des positions mentionnées précédemment ou si aucune autre expression ne nécessite un étirement de l'opérateur à sa dimension), alors il prend la dimension stantard (non étirée) déterminée par la police et son corps courant.

Lorsqu'un opérateur étirable est obligé de s'étirer, mais que toutes les autres expressions dans l'élément conteneur (cf. précédemment) décrit ci-dessus) sont également étirables, alors tous les éléments qui peuvent l'être devraient croître jusqu'au maximum des dimensions non étirées normales de tous les éléments de l'objet conteneur. Si la valeur des attributs minsize ou maxsize les en empêche, alors c'est cette valeur (minsize ou maxsize) qui sera utilisée.

Par exemple, dans un élément mrow ne contenant rien d'autre que des opérateurs étirables verticalement, chaque opérateur devrait s'étirer au maximum de toutes leurs dimensions non étirées normales, tant que la valeur d'un autre attribut ne contredise ce comportement. Bien sûr, en raison des limitations des polices ou du rendu d'une police, les dimensions étirées finales seront peut-être seulement approximatives à défaut d'être les mêmes.

3.2.5.9 Les autres attributs de l'élément mo

L'attribut largeop indique si l'opérateur devrait ou non être dessiné plus grand que la normale si displaystyle="true" dans l'environnement de rendu courant. Cela correspond à peu près à la valeur \displaystyle du paramètre de style de TEX. MathML utilise deux attributs, displaystyle et scriptlevel, pour contrôler les caractéristiques de présentation orthogonales que TEX code par un seul attribut style avec les valeurs \displaystyle, \textstyle, \scriptstyle et \scriptscriptstyle. Ces attributs sont abordés plus en détails dans la section 3.3.4 Les changements de style (mstyle) décrivant l'élément mstyle. Remarquez qu'on peut définir ces attributs directement dans la balise ouvrante d'un élément mstyle mais pas sur la plupart des autres éléments. Les opérateurs &int; et &prod; sont des exemples de ce type d'agrandissement.

L'attribut movablelimits définit si les écritures dessous et dessus, attachées à l'élément mo en question, devraient être dessinées en indice et en exposant pour displaystyle="false". La définition movablelimits="false" indique de ne jamais représenter les écritures dessous et dessus par des indices et des exposants. En général, l'attribut displaystyle a la valeur "true" pour les mathématiques affichées et la valeur "false" pour les mathématiques en-ligne. L'attribut displaystyle a également la valeur "false" par défaut dans les tables, les écritures et les fractions, plus quelques autres cas particuliers décrits dans la section 3.3.4 Les changements de style (mstyle). Les opérateurs avec movablelimits="true" s'afficheront donc avec des limites (c.à.d., des écritures dessous et dessus) pour les mathématiques affichées, et avec des indices et des exposants pour les mathématiques en-ligne, les tables, les écritures, et ainsi de suite. Comme exemple, les opérateurs sum, prod et lim sont typiquement définis avec movablelimits="true".

L'attribut accent détermine s'il faut traiter ou non par défaut cet opérateur comme un accent (marque diacritique) lorsqu'il apparaît dans une écriture dessous ou dessus ; cf. les éléments munder, mover et munderover (section 3.4.4 L'écriture dessous (munder), section 3.4.5 L'écriture dessus (mover) et section 3.4.6 Les paires dessous-dessus (munderover)).

L'attribut separator peut influencer le saut de ligne automatique chez les moteurs de rendu qui placent les opérateurs infixes ordinaires plutôt au début de la ligne coupée qu'à la fin (c'est-à-dire, qui permettent d'éviter les sauts de ligne juste après ces opérateurs), parce qu'on devrait éviter un saut de ligne juste avant un séparateur mais il est acceptable juste après.

L'attribut fence n'a aucune influence sur les règles de rendu suggéré présentées ici, et il n'est pas indispensable pour rendre correctement la notation traditionnelle à l'aide de ces règles. On le fournit de sorte que des moteurs de rendu MathML spécifiques, tout particulièrement les moteurs de rendu non visuels, disposent d'une option afin d'utiliser cette information.

3.2.6 Le texte (mtext)

3.2.6.1 Description

L'élément mtext sert à représenter un texte arbitraire à rendre en tant que tel. En général, on emploie l'élément mtext pour un texte de commentaire.

Remarquez qu'un texte dont le rôle de notation est clairement défini sera peut-être mieux balisé en recourant à un élément mi ou mo ; cet aspect est précisé après.

On peut se servir d'un élément mtext pour contenir des blancs interprétables, c'est-à-dire, des caractères invisibles destinés à modifier le positionnement des éléments environnants. Pour les médias non graphiques, ces caractères auront un effet analogue, comme introduire des temporisations positives ou négatives ou modifier le rythme d'un moteur de rendu sonore. Ils sont différents des blancs éventuels dans la source MathML, qui se composent d'espaces, de sauts de ligne, de tabulations ou de retours chariot ; les blancs directement présents dans la source sont rognés et se rétractent (cf. la section 2.4.6 La rétractation des blancs en entrée). Les blancs à rendre comme partie du contenu d'un élément doivent être représentés par des références d'entités ou des éléments mspace (sauf quand il s'agit de caractères espaces seuls entre des caractères non blancs).

Les blancs interprétables peuvent avoir une chasse positive ou négative, ainsi que &ThinSpace; et &NegativeThinSpace;, ou une chasse nulle, ainsi que &ZeroWidthSpace;. La liste complète de ces caractères est donnée dans le chapitre 6 Les caractères, les entités et les fontes. Remarquez que, dans MathML, rien ne distingue formellement les blancs interprétables d'une quelconque autre classe de caractères, que ce soit dans un élément mtext ou dans n'importe quel autre élément.

Les blancs interprétables peuvent aussi comprendre des caractères qui influencent l'alignement ou le saut de ligne. En voici quelques-uns :

Nom de l'entité Emploi (brève description)
&NewLine; commence une nouvelle ligne sans indentation
&IndentingNewLine; commence une nouvelle ligne avec indentation
&NoBreak; interdit un saut de ligne à cet endroit
&GoodBreak; si un saut de ligne est nécessaire sur la ligne, le choisir à cet endroit
&BadBreak; si un saut de ligne est nécessaire sur la ligne, l'éviter à cet endroit

Pour la liste complète des entités MathML, cf. le chapitre 6 Les caractères, les entités et les fontes.

3.2.6.2 Attributs

L'élément mtext accepte les attributs listés dans la section 3.2.2 Les attributs de style mathématique communs des éléments atomiques.

Cf. également l'avertissement concernant le regroupement légal des éléments pareils à des espaces dans la section 3.2.7 L'espacement (mspace) et l'avertissement concernant l'utilisation de ces éléments pour déformer ou véhiculer une signification dans la section 3.3.6 L'ajustement de l'espace autour du contenu (mpadded).

3.2.6.3 Exemples

<mtext> Théorème 1 : </mtext>
<mtext> &ThinSpace; </mtext>
<mtext> &ThickSpace;&ThickSpace; </mtext>
<mtext> /* un commentaire */ </mtext>

3.2.6.4 Le mélange du texte et des mathématiques

Dans certains cas, on représentera peut-être mieux un texte imbriqué dans des mathématiques en recourant à des éléments mo ou mi. Par exemple, on pourrait représenter l'expression il existe \delta>0 tel que f(x) <1, équivalant à \exists \delta>0 \backepsilon f(x)<1, par :

<mrow>
  <mo> il existe </mo>
  <mrow>
    <mrow>
      <mi> &delta; </mi>
      <mo> &gt; </mo>
      <mn> 0 </mn>
    </mrow>
    <mo> tel que </mo>
    <mrow>
      <mrow>
        <mi> f </mi>
        <mo> &ApplyFunction; </mo>
        <mrow>
          <mo> ( </mo>
          <mi> x </mi>
          <mo> ) </mo>
        </mrow>
      </mrow>
      <mo> &lt; </mo>
      <mn> 1 </mn>
    </mrow>
  </mrow>
</mrow>

Voici un exemple faisant intervenir un élément mi : x+x2+···+xn. Dans cet exemple, on devrait représenter l'ellipse à l'aide d'un élément mi parce qu'elle prend la place d'un terme dans la somme (cf. la section 3.2.3 Les identificateurs (mi)).

À l'inverse, on représentera mieux le texte d'un exposé dans MathML avec un élément mtext. Voici un exemple :

Théorème 1 : si x > 1, alors x2 > x.

Par contre, lorsqu'un code MathML est imbriqué dans HTML, ou dans un autre langage de balisage de document, l'exemple sera probablement mieux rendu en plaçant seulement les deux inégalités dans un code MathML et en laissant le texte dans le code HTML environnant.

Un autre facteur à prévoir dans le choix du balisage du texte est l'effet sur le rendu. Le texte englobé dans un élément mo ne se trouvera vraisemblablement pas dans le dictionnaire d'opérateurs d'un moteur de rendu, et il sera donc rendu avec le format et l'espacement d'un opérateur non reconnu, qui seront peut-être, ou peut-être pas, meilleurs que ceux du texte obtenu avec un élément mtext. Une entité ellipse dans un élément mi sera mieux espacée en prenant la place d'un terme dans une série qu'en apparaissant dans un élément mtext.

3.2.7 L'espacement (mspace)

3.2.7.1 Description

L'élément vide mspace représente un espace quelconque dont la dimension est réglée par ses attributs. On peut aussi s'en servir pour suggérer des sauts de ligne à un moteur de rendu visuel. Remarquez que les valeurs par défaut des attributs ont été choisies afin de n'avoir normalement aucun effet sur le rendu. L'élément mspace est donc généralement employé avec une ou plusieurs valeurs d'attribut définies explicitement.

3.2.7.2 Attributs

Outre les attributs listés ci-dessous, l'élément mspace admet les attributs id, xref, class et style, décrits dans la section 2.4.5 Les attributs communs à tous les éléments MathML.

Nom Valeurs Valeur par défaut
width number h-unit | namedspace 0em
height number v-unit 0ex
depth number v-unit 0ex
linebreak auto | newline | indentingnewline | nobreak | goodbreak | badbreak auto

Les variables h-unit et v-unit représentent, respectivement, des unités de longueur horizontales et verticales (cf. la section 2.4.4.2 Les attributs avec des unités).

L'attribut linebreak sert à suggérer un saut de ligne à un moteur de rendu visuel. La valeur par défaut est "auto", pour laquelle un moteur de rendu devrait employer l'algorithme de saut de ligne par défaut qu'il utiliserait normalement. Les significations des autres valeurs possibles de l'attribut linebreak ont été décrites précédemment dans la discussion à propos des blancs interprétables dans l'élément mtext. Cf. la section 3.2.6 Le texte (mtext) pour des précisions.

Au cas où on paramètre des attributs de dimension avec un attribut de saut de ligne, ce dernier sera ignoré.

Notez l'avertissement ci-dessous concernant le regroupement légal des éléments pareils à des espaces et l'avertissement concernant l'utilisation de ces éléments pour déformer ou véhiculer une signification dans la section 3.3.6 L'ajustement de l'espace autour du contenu (mpadded). Voir également les autres éléments qui peuvent se rendre comme des blancs, à savoir les éléments mtext, mphantom et maligngroup.

3.2.7.3 La définition des éléments pareils à des espaces

Un certain nombre d'éléments de présentation MathML sont pareils à des espaces, au sens où ils se rendent habituellement comme des blancs, et ils n'ont aucune influence sur la signification mathématique des expressions dans lesquelles ils apparaissent. En conséquence, ces éléments fonctionnent souvent de façon exceptionnelle dans d'autres expressions MathML. Par exemple, les éléments pareils à des espaces sont manipulés de façon particulière dans les règles de rendu visuel suggéré pour l'élément mo, qui sont décrites dans la section 3.2.5 Les opérateurs, les délimiteurs, les séparateurs ou les accents (mo). On définit les éléments MathML suivants comme pareils à des espaces :

Remarquez qu'un élément mphantom n'est pas automatiquement défini comme pareil à un espace, sauf si son contenu l'est. Car l'espacement d'un opérateur est influencé par les éléments adjacents selon qu'ils sont ou non pareils à des espaces. Dans la mesure où l'élément mphantom sert principalement à aider dans l'alignement des expressions, les opérateurs adjacents devraient se comporter comme s'ils étaient adjacents au contenu de l'élément mphantom, et non à l'aire d'un blanc dont la dimension serait équivalente.

3.2.7.4 Le regroupement légal des éléments pareils à des espaces

Les auteurs qui insèrent des éléments pareil à des espaces ou des éléments mphantom dans une expression MathML existante devraient noter que ces éléments comptent comme arguments, dans les éléments qui imposent un nombre spécifique d'arguments ou qui les interprètent différemment selon leur position.

Les éléments pareils à des espaces insérés dans un élément MathML de ce type devraient donc être regroupés avec un argument voisin de l'élément en question, en introduisant pour cela un élément mrow. Par exemple, pour un alignement vertical sur le bord droit de la base d'un exposant :

<msup>
  <mi> x </mi>
  <malignmark edge="right"/>
  <mn> 2 </mn>
</msup>

Cette expression est illégale parce que l'élément msup doit avoir deux arguments exactement ; l'expression correcte serait :

<msup>
  <mrow>
    <mi> x </mi>
    <malignmark edge="right"/>
  </mrow>
  <mn> 2 </mn>
</msup>

Voir également l'avertissement à propos de la déformation dans la section 3.3.6 L'ajustement de l'espace autour du contenu (mpadded).

3.2.8 Les chaînes littérales (ms)

3.2.8.1 Description

L'élément ms sert à représenter des chaînes littérales dans les expressions prévues pour être interprétées par des systèmes de calcul algébrique ou d'autres systèmes contenant des langages de programmation. Par défaut, les chaînes littérales sont affichées entourées par des guillemets doubles. Comme l'explique la section 3.2.6 Le texte (mtext), un texte ordinaire imbriqué dans une expression mathématique devrait être balisé avec un élément mtext ou, dans certains cas, des éléments mo ou mi mais jamais avec un élément ms.

Remarquez que les chaînes littérales codées à l'aide de ms sont des chaînes Unicode et non des chaînes ASCII. En pratique, les caractères non-ASCII seront habituellement représentés par des références d'entités. Par exemple, l'expression <ms>&amp;</ms> représente une chaîne littérale contenant un seul caractère, &, et l'expression <ms>&amp;amp;</ms> une chaîne littérale contenant cinq caractères dont le premier est &.

Comme tous les éléments atomiques, l'élément ms rogne et rétracte les blancs de son contenu, selon les règles énoncées dans la section 2.4.6 La rétractation des blancs en entrée, et on devrait donc coder les blancs qui doivent rester dans le contenu comme cela y est expliqué.

3.2.8.2 Attributs

Les éléments ms acceptent les attributs listés dans la section 3.2.2 Les attributs de style mathématique communs des éléments atomiques et en supplément :

Nom Valeurs Valeur par défaut
lquote string &quot;
rquote string &quot;

Pour les moteurs de rendu visuel, le contenu d'un élément ms est rendu habituellement sans espacement supplémentaire ajouté autour de la chaîne et avec un caractère guillemet au début et à la fin de celle-ci. Par défaut, les caractères guillemets à gauche et à droite sont tous les deux un guillemet double standard &quot;. Toutefois, on peut remplacer ces caractères par les attributs lquote et rquote respectivement.

Le contenu des éléments ms devraient être rendu avec un masquage visible de certains des caractères du contenu, dont au moins le guillemet double même et, de préférence, les blancs sauf les caractères espaces individuels. Cette intention s'adresse au lecteur afin qu'il puisse voir que l'expression est une chaîne littérale et quels caractères forment exactement son contenu. Par exemple, l'expression <ms>le guillemet double est "</ms> devrait être rendue par "le guillemet double est \"".

3.2.9 L'ajout de nouveaux glyphes de caractère à MathML (mglyph)

3.2.9.1 Description

Unicode définit un grand nombre de caractères utilisés en mathématiques et, dans la plupart des cas, les glyphes représentant ces caractères sont largement répandus dans des polices diverses. Bien que presque tous les besoins des utilisateurs puissent être satisfaits par ces caractères, MathML reconnaît que les mathématiques ne sont pas figées et que des nouveaux caractères sont ajoutés opportunément. Les caractères qui finissent par être bien acceptés seront éventuellement incorporés par le Consortium Unicode ou d'autres organismes de normalisation, mais c'est un processus souvent long. En attendant, un mécanisme qui permet d'accéder aux glyphes représentant ces caractères, issus de polices non normalisées, est nécessaire.

L'élément mglyph est le moyen avec lequel les utilisateurs peuvent accéder directement aux glyphes de caractères non définis par Unicode ou inconnus du moteur de rendu. De la même façon, on peut aussi se servir de l'élément mglyph pour sélectionner des variantes des glyphes de caractères Unicode existants, ce qui peut être souhaitable lorsqu'une variante de glyphe a commencé à se différencier comme nouveau caractère en adoptant une signification mathématique distincte.

L'élément mglyph nomme un glyphe de caractère spécifique qui est valide dans tout contenu des terminaux MathML listés dans la section 3.1.6 Le sommaire des éléments de présentation (mi, etc.) ou la section 4.2.2 Les conteneurs (ci, etc.), sauf restriction d'un attribut (par exemple, base="2" pour l'élément <cn>). Afin qu'un moteur de rendu visuel puisse rendre le caractère, on doit lui indiquer quelle police et quel index dans cette police utiliser.

3.2.9.2 Attributs

Les éléments mglyph acceptent les attributs listés dans la section 3.2.2 Les attributs de style mathématique communs des éléments atomiques et les attributs supplémentaires listés ici.

Nom Valeurs Valeur par défaut
alt string required
fontfamily string | css-fontfamily required
index integer required

L'attribut alt fournit un nom de rechange pour le glyphe. Si la police indiquée est introuvable, le moteur de rendu peut utiliser ce nom dans un message d'avertissement, ou une notation de glyphe inconnu. Le nom sera peut-être aussi utilisé par un moteur de rendu sonore ou un système de traitement symbolique, et il devrait être descriptif. Les attributs fontfamily et index identifient l'élément mglyph de façon unique ; les applications qui doivent déterminer l'identité de deux caractères/glyphes devraient considérer comme identiques deux éléments mglyph dont les valeurs des attributs fontfamily et index sont les mêmes. Le test d'identité ne devrait pas tenir compte de l'attribut alt.

Les attributs fontfamily et index nomment une police et y désigne une position, respectivement. Toutes les propriétés de police, sauf fontfamily, sont héritées. Les variantes de la police (par exemple, la variante en caractères gras) susceptibles d'être héritées peuvent être ignorées si la variante est absente.

Les auteurs doivent savoir que le rendu exige les polices appelées par l'élément mglyph, qui peuvent être inaccessibles au moteur de rendu MathML ou qui ne sont pas gérées par le système sur lequel tourne le moteur de rendu. Pour ces raisons, on encourage les auteurs à utiliser l'élément mglyph seulement quand c'est absolument nécessaire, et pas pour des effets de style.

3.2.9.3 Exemple

L'exemple suivant montre comment un chercheur pourrait utiliser la construction mglyph avec une police expérimentale pour travailler avec une notation de groupe de tresses.

<mrow>
  <mi><mglyph fontfamily="ma-police-de-tresses" index="2" alt="tresse23"/></mi>
  <mo>+</mo>
  <mi><mglyph fontfamily="ma-police-de-tresses" index="5" alt="tresse132"/></mi>
  <mo>=</mo>
  <mi><mglyph fontfamily="ma-police-de-tresses" index="3" alt="tresse13"/></mi>
</mrow>

Ce qui pourrait se rendre par :

\includegraphics{braids}

3.3 Les schémas généraux de disposition

Outre les atomes, il existe plusieurs familles d'éléments de présentation MathML. Une famille traite des diverses notations d'écritures, telles que les indices et les exposants. Une autre famille concerne les matrices et les tables. Les éléments restants, dont il est question dans cette section, décrivent les autres notations de base, tels que les fractions et les radicaux, ou se rapportent à des fonctions générales, tels que le paramétrage des propriétés de style et la gestion d'erreurs.

3.3.1 Le regroupement horizontal des sous-expressions (mrow)

3.3.1.1 Description

L'élément mrow sert à regrouper un nombre quelconque de sous-expressions, constituées habituellement par un ou plusieurs éléments mo qui agissent comme opérateurs pour une ou plusieurs expressions dont ce sont les opérandes.

Plusieurs éléments traitent leurs arguments comme s'ils étaient contenus dans un élément mrow. Cf. la discussion sur les éléments mrow inférés dans la section 3.1.3 Les arguments obligatoires. Voir aussi l'élément mfenced (dans la section 3.3.8 Les expressions comprises entre une paire de délimiteurs (mfenced)), qui peut former un élément mrow effectif contenant ses arguments séparés par des virgules.

3.3.1.2 Attributs

Cet élément admet seulement les attributs id, xref, class et style, qui sont décrits dans la section 2.4.5 Les attributs communs à tous les éléments MathML.

Les éléments mrow sont typiquement rendus, visuellement, comme une rangée horizontale de leurs arguments, de gauche à droite dans l'ordre où ils adviennent, ou de façon sonore, comme une séquence des rendus des arguments. La description des règles de rendu suggéré pour les éléments mo, dans la section 3.2.5 Les opérateurs, les délimiteurs, les séparateurs ou les accents (mo), supposent que tout l'espacement horizontal entre les opérateurs et leurs opérandes est ajouté par le rendu des éléments mo (ou, plus généralement, des opérateurs embellis), et non par le rendu des éléments mrow qui les contiennent.

MathML est conçu afin que les moteurs de rendu puissent automatiquement réaliser le saut de ligne des expressions (c'est-à-dire, répartir les expressions trop longues sur plusieurs lignes), sans obliger les auteurs à indiquer explicitement comment le faire. Car on ne peut pas choisir correctement les positions des sauts de ligne sans connaître la largeur du dispositif d'affichage et le corps de la police courante qui, dans beaucoup d'utilisations de MathML, ne seront pas connues, sauf du moteur de rendu lors de chaque rendu.

La détermination des positions correctes des sauts de ligne est complexe et les règles applicables ne sont pas décrites ici ; chaque moteur de rendu MathML décide de les faire s'il y a lieu et comment. Généralement, le saut de ligne impliquera une sélection des bons points d'insertion des caractères saut de ligne entre les arguments successifs des éléments mrow.

Bien que MathML n'impose aucun saut de ligne ni ne définit d'algorithme de saut de ligne particulier, il dispose de plusieurs caractéristiques prévues afin que ces algorithmes puissent produire de bons résultats. À savoir l'emploi d'entités spéciales pour certains opérateurs, y compris les opérateurs invisibles (cf. la section 3.2.5 Les opérateurs, les délimiteurs, les séparateurs ou les accents (mo)), ou pour fournir des indications de saut de ligne quand c'est nécessaire (cf. la section 3.2.6 Le texte (mtext)), et la possibilité d'utiliser des éléments mrow imbriqués pour décrire des sous-expressions (cf. ci-dessous).

Un élément mrow avec un seul argument

Les moteurs de rendu MathML sont tenus de traiter une élément mrow contenant un seul argument comme équivalent en tous points à l'argument s'il advenait seul, à condition qu'il n'y ait aucun attribut dans la balise ouvrante de l'élément mrow. S'il y en a dans la balise ouvrante de l'élément mrow, aucune obligation d'équivalence n'est imposée. Cette condition d'équivalence permet de simplifier la mise en œuvre des logiciels générant du code MathML, tels que les outils de création d'après gabarits. Elle influence directement les définitions des opérateurs embellis et des éléments pareils à des espaces, et les règles de détermination de la valeur par défaut de l'attribut form de l'élément mo ; cf. la section 3.2.5 Les opérateurs, les délimiteurs, les séparateurs ou les accents (mo) et la section 3.2.7 L'espacement (mspace). Cf. également la discussion à propos de l'équivalence des expressions MathML dans le chapitre 7 L'interface MathML.

3.3.1.3 Le bon regroupement des sous-expressions avec l'élément mrow

L'auteur du document devrait regrouper les sous-expressions de la même manière qu'elles le sont dans l'interprétation mathématique de l'expression ; c'est-à-dire, conformément à l'arbre de syntaxe sous-jacent de l'expression. En particulier, les opérateurs et leurs arguments mathématiques devraient se tenir dans un seul élément mrow ; plusieurs opérateurs ne devraient advenir directement dans un élément mrow que si on peut considérer (au sens syntaxique) qu'ils agissent ensemble sur les arguments entrelacés, par exemple, un seul terme et les parenthèses qui l'entourent, des chaînes d'opérateurs relationnels ou des séquences de termes séparés par des opérateurs + et -. On donne une règle précise ci-dessous.

Un bon regroupement vise plusieurs objectifs : améliorer l'affichage en agissant éventuellement sur l'espacement ; permettre des sauts de ligne et des indentations plus rationnels et simplifier l'interprétation sémantique possible des éléments de présentation par les systèmes de calcul algébrique et les moteurs de rendu sonore.

Quoiqu'un mauvais regroupement produise parfois un rendu non optimal et puisse souvent rendre une interprétation non visuelle difficile voire impossible, la syntaxe MathML permet n'importe quel regroupement d'expressions utilisant des éléments mrow ; par conséquent, les moteurs de rendu ne devraient pas présupposer que les règles de bon regroupement seront respectées.

Une règle précise de bon regroupement

Un règle précise, à propos de savoir quand et comment imbriquer des sous-expressions en utilisant l'élément mrow, se révèle très appréciable lorsqu'il s'agit de générer automatiquement du code MathML par conversion depuis d'autres formats mathématiques affichés, tel que TEX, qui ne définissent pas toujours comment le faire. Si on souhaite une règle de regroupement précise, on devrait utiliser la suivante :

Deux opérateurs adjacents (c.à.d., des éléments mo, peut-être embellis), éventuellement séparés par des opérandes (c.à.d., tout sauf des opérateurs), devraient se tenir dans le même élément mrow seulement si l'opérateur de gauche a une forme infixée ou préfixée (peut-être inférée), si l'opérateur de droite a une forme infixée ou suffixée et si les deux opérateurs sont listés dans le même groupe d'entrées du dictionaire des opérateurs, qui est fourni dans l'Annexe F Le dictionnaire d'opérateurs. Dans tous les autres cas, on devrait utiliser des éléments mrow imbriqués.

Lors de la formation d'un élément mrow imbriqué (pendant la génération du code MathML) qui comprend uniquement l'un des deux opérateurs successifs, avec les formes mentionnées précédemment (ce qui signifie que l'un ou l'autre opérateur est susceptible d'agir, en principes, sur le ou les opérandes intermédiaires), il est nécessaire de décider lequel des opérateurs agit directement sur ces opérandes (ou agirait, si ces opérandes étaient présents). Idéalement, on devrait le déterminer d'après l'expression originale ; par exemple, dans une conversion depuis un format fondé sur une préséance des opérateurs, il s'agirait de l'opérateur avec la plus haute priorité. Si on ne peut pas le déterminer directement d'après l'expression originale, on peut supposer que c'est l'opérateur advenant en dernier dans le dictionnaire d'opérateurs suggérés (cf. Annexe F Le dictionnaire d'opérateurs) qui sera prioritaire dans ce cas.

Remarquez que la règle ci-dessus n'a aucune influence sur la validité ou non d'une expression MathML quelconque, seulement sur la façon recommandée de générer du code MathML d'après d'autres formats d'affichage des mathématiques ou directement d'après une notation écrite.

(La section 3.2.5 Les opérateurs, les délimiteurs, les séparateurs ou les accents (mo) définit une partie de la terminologie employée dans l'énoncé de la règle précédente.)

3.3.1.4 Exemples

Comme exemple, l'expression 2x+y-z devrait s'écrire :

<mrow>
  <mrow>
    <mn> 2 </mn>
    <mo> &InvisibleTimes; </mo>
    <mi> x </mi>
  </mrow>
  <mo> + </mo>
  <mi> y </mi>
  <mo> - </mo>
  <mi> z </mi>
</mrow>

Le bon codage de (xy) offre un exemple moins évident d'imbrication d'éléments mrow :

<mrow>
  <mo> ( </mo>
  <mrow>
    <mi> x </mi>
    <mo> , </mo>
    <mi> y </mi>
  </mrow>
  <mo> ) </mo>
</mrow>

Un élément mrow est nécessaire ici entre les parenthèses, puisque les parenthèses et les virgules, assimilées à des opérateurs de délimitation et de séparation, n'agissent pas concurremment sur leurs arguments.

3.3.2 Les fractions (mfrac)

3.3.2.1 Description

L'élément mfrac sert pour des fractions. On peut aussi l'utiliser pour baliser des objets pareils à des fractions, tels que les coefficients binomiaux et les symboles de Legendre. La syntaxe de l'élément mfrac est la suivante :

<mfrac> numérateur dénominateur </mfrac>

3.3.2.2 Les attributs de l'élément mfrac

Outre les attributs listés ci-dessous, cet élément admet les attributs id, xref, class et style, qui sont décrits dans la section 2.4.5 Les attributs communs à tous les éléments MathML.

Nom Valeurs Valeur par défaut
linethickness number [ v-unit ] | thin | medium | thick 1 (épaisseur du trait de fraction)
numalign left | center | right center
denomalign left | center | right center
bevelled true | false false

L'attribut linethickness indique l'épaisseur de la barre de fraction horizontale, ou trait de fraction, employée habituellement pour représenter les fractions. Une fraction définie par linethickness="0" est rendue sans barre et peut servir dans des coefficients binomiaux. On pourra utiliser un attribut linethickness de valeur supérieure à un pour des fractions imbriquées. Ces cas sont illustrés ci-dessous :

{a \choose b} \quad {a \over b} \above1pt {c \over d}

En général, la valeur de l'attribut linethickness peut être un nombre, comme multiplicateur de l'épaisseur par défaut de la barre de fraction (MathML ne définit pas d'épaisseur par défaut), ou un nombre avec une unité de longueur verticale (cf. la section 2.4.4.2 Les attributs avec des unités), ou l'un des mots-clés medium (même chose que "1"), thin (plus fin que "1" ou selon le moteur de rendu sinon) ou thick (plus épais que "1" ou selon le moteur de rendu sinon).

Les attributs numalign et denomalign contrôlent, respectivement, l'alignement horizontal du numérateur et du dénominateur. Habituellement, les numérateurs et les dénominateurs sont centrés, mais un très long numérateur, ou dénominateur, peut s'afficher sur plusieurs lignes et un alignement à gauche conviendra mieux à son affichage.

L'attribut bevelled détermine si la fraction s'affiche avec le numérateur au-dessus du dénominateur, séparés par un trait horizontal, ou si le numérateur légèrement surélevé est séparé du dénominateur légèrement abaissé par un trait diagonal. La dernière forme correspond à l'attribut avec la valeur "true" et elle offre une apparence plus compacte pour les numérateurs et dénominateurs simples. Voici un exemple illustrant la forme biseautée :

\frac{1}{x^3 + \frac{x}{3}} = \raisebox{1ex}{$1$}\! \left/ \!\raisebox{-1ex}{$x^3+\frac{x}{3}$} \right.

L'élément mfrac établit la valeur de l'attribut displaystyle à "false" ou, s'il avait déjà la valeur "false", incrémente l'attribut scriptlevel d'une unité, au sein du numérateur et du dénominateur. Ces attributs sont hérités par chaque élément à travers son environnement de rendu, mais on peut les fixer explicitement seulement sur l'élément mstyle. (Cf. la section 3.3.4 Les changements de style (mstyle)).

3.3.2.3 Exemples

Les exemples illustrés précédemment peuvent être représentés dans MathML par :

<mrow>
   <mo> ( </mo>
   <mfrac linethickness="0">
      <mi> a </mi>
      <mi> b </mi>
   </mfrac>
   <mo> ) </mo>
</mrow>
<mfrac linethickness="2">
   <mfrac>
      <mi> a </mi>
      <mi> b </mi>
   </mfrac>
   <mfrac>
      <mi> c </mi>
      <mi> d </mi>
   </mfrac>
</mfrac>
<mfrac>
   <mn> 1 </mn>
   <mrow>
      <msup>
         <mi> x </mi>
         <mn> 3 </mn>
       </msup>
       <mo> + </mo>
       <mfrac>
         <mi> x </mi>
         <mn> 3 </mn>
       </mfrac>
   </mrow>
</mfrac>
<mo> = </mo>
<mfrac bevelled="true">
   <mn> 1 </mn>
   <mrow>
      <msup>
         <mi> x </mi>
         <mn> 3 </mn>
       </msup>
       <mo> + </mo>
       <mfrac>
         <mi> x </mi>
         <mn> 3 </mn>
       </mfrac>
   </mrow>
</mfrac>

Un exemple plus générique :

<mfrac>
   <mrow>
      <mn> 1 </mn>
      <mo> + </mo>
      <msqrt>
         <mn> 5 </mn>
      </msqrt>
   </mrow>
   <mn> 2 </mn>
</mfrac>

3.3.3 Les radicaux (msqrt, mroot)

3.3.3.1 Description

Ces éléments construisent des radicaux. L'élément msqrt sert pour les racines carrées, tandis que l'élément mroot sert à dessiner des radicaux avec des indices, par exemple, une racine cubique. La syntaxe de ces élément est la suivante :

<msqrt> base </msqrt>
<mroot> base indice </mroot>

L'élément mroot impose deux arguments exactement. Par contre, l'élément msqrt accepte un nombre quelconque d'arguments ; si ce nombre n'est pas égal à 1, son contenu est traité comme un seul élément mrow inféré contenant ses arguments, comme cela est décrit dans la section 3.1.3 Les arguments obligatoires.

3.3.3.2 Attributs

Cet élément admet seulement les attributs id, xref, class et style, qui sont décrits dans la section 2.4.5 Les attributs communs à tous les éléments MathML.

L'élément mroot incrémente l'attribut scriptlevel de deux unités et fixe la valeur de l'attribut displaystyle à "false" au sein de l'indice, mais laisse les deux attributs inchangés au sein de la base. L'élément msqrt laisse les deux attributs inchangés dans tous ses arguments. Ces attributs sont hérités par chaque élément d'après son environnement de rendu, mais on ne peut les fixer explicitement que sur l'élément mstyle. (Cf. la section 3.3.4 Les changements de style (mstyle)).

3.3.4 Les changement de style (mstyle)

3.3.4.1 Description

L'élément mstyle sert à effectuer des changements de style qui affectent le rendu de son contenu. On peut donner à l'élément mstyle n'importe quel attribut accepté par les éléments de présentation MathML, à condition que la valeur de l'attribut soit héritée, calculée ou ait une valeur par défaut ; l'élément mstyle n'accepte pas les attributs d'éléments de présentation dont les valeurs sont obligatoires. En outre, l'élément mstyle peut recevoir certains attributs spéciaux listés ci-dessous.

L'élément mstyle accepte un nombre quelconque d'arguments. Si ce nombre n'est pas égal à 1, son contenu est traité comme un seul élément mrow inféré formé à partir de tous ses arguments, comme cela est décrit dans la section 3.1.3 Les arguments obligatoires.

En simplifiant, l'élément mstyle a pour effet de changer la valeur par défaut d'un attribut des éléments qu'il contient. Les changements de style se déroulent selon un scénario parmi plusieurs, en fonction de la définition de la valeur par défaut de l'attribut. Voici ces cas :

Remarquez que les valeurs d'attribut héritées, d'une façon ou d'une autre, d'un élément mstyle affectent un élément donné dans le contenu de l'élément mstyle seulement si cet attribut n'a pas reçu de valeur dans la balise ouvrante de l'élément en question. Quel que soit l'élément où un attribut est fixé explicitement, la valeur définie dans la balise ouvrante annule la valeur héritée. La seule exception à cette règle est lorsque la valeur donnée dans la balise ouvrante est documentée comme produisant un changement incrémentiel de la valeur qui est héritée du contexte ou de l'environnement de rendu de l'élément.

Remarquez également que la différence entre les attributs hérités et ceux non hérités fixés par un élément mstyle, dont l'explication précède, importe seulement lorsque l'attribut est fixé sur un certain élément contenu dans l'élément mstyle, avec des enfants qui le fixent aussi. le règlent aussi. Cela ne concerne donc jamais les attributs, comme color, qu'on peut seulement fixer sur les éléments atomiques (ou sur l'élément mstyle même).

L'élément mpadded constitue une exception, car l'élément mstyle ne peut pas fixer ses attributs. L'élément mpadded partagent plusieurs noms d'attributs avec les éléments mspace et mo. Ainsi, lorsqu'on définit les attributs width, height et depth sur un élément mstyle, ils s'appliquent seulement à l'élément mspace et non aux attributs correspondants de l'élément mpadded. De même, lorsque l'élément mstyle fixe un attribut lspace, il s'applique uniquement à l'élément mo.

3.3.4.2 Attributs

Comme mentionné précédemment, l'élément mstyle accepte tous les attributs de tous les éléments de présentation dont la valeur n'est pas obligatoire. C'est-à-dire, l'élément mstyle accepte tous les attributs qui ont une valeur par défaut explicite ou une valeur par défaut héritée ou bien calculée.

Cet élément accepte également les attributs id, xref, class et style, qui sont décrits dans la section 2.4.5 Les attributs communs à tous les éléments MathML.

En plus, l'élément mstyle peut recevoir les attributs spéciaux suivants qui sont hérités par chaque élément MathML faisant partie de son environnement de rendu :

Nom Valeurs Valeur par défaut
scriptlevel ['+' | '-'] unsigned-integer héritée
displaystyle true | false héritée
scriptsizemultiplier number 0.71
scriptminsize number v-unit 8pt
color #rgb | #rrggbb | html-color-name héritée
background #rgb | #rrggbb | transparent | html-color-name transparent
veryverythinmathspace number h-unit 0.0555556em
verythinmathspace number h-unit 0.111111em
thinmathspace number h-unit 0.166667em
mediummathspace number h-unit 0.222222em
thickmathspace number h-unit 0.277778em
verythickmathspace number h-unit 0.333333em
veryverythickmathspace number h-unit 0.388889em
negativeveryverythinmathspace number h-unit 0.0555556em
negativeverythinmathspace number h-unit 0.111111em
negativethinmathspace number h-unit 0.166667em
negativemediummathspace number h-unit 0.222222em
negativethickmathspace number h-unit 0.277778em
negativeverythickmathspace number h-unit 0.333333em
negativeveryverythickmathspace number h-unit 0.388889em
Les attributs scriptlevel et displaystyle

MathML utilise les deux attributs displaystyle et scriptlevel pour contrôler les caractéristiques de présentation orthogonales, que TEX code par le seul attribut style avec les valeurs \displaystyle, \textstyle, \scriptstyle et \scriptscriptstyle. Les valeurs des attributs displaystyle et scriptlevel correspondant à ces styles de TEX seraient, respectivement, "true" et "0", "false" et "0", "false" et "1", et "false" et "2".

L'attribut displaystyle a pour effet principal de déterminer celui des autres attributs, tels que les attributs largeop et movablescripts de l'élément mo. L'attribut scriptlevel a pour effet principal de contrôler le corps de la police. Normalement, plus la valeur de scriptlevel est élevée, plus le corps de la police est petit. (Les moteurs de rendu non visuels peuvent répondre au corps de la police de façon analogue selon le médium). Les moteurs de rendu plus sophistiqués peuvent aussi utiliser ces attributs d'autres façons, comme rendre les expressions définies avec displaystyle="false" par une plus grande compression verticale.

Les valeurs initiales des attributs de l'expression la plus externe d'une instance MathML sont fondées sur son environnement de rendu. Une liste brève de schémas de disposition, décrits ensuite, modifie ces valeurs dans certaines de leurs sous-expressions. Sinon les valeurs sont déterminées par héritage tant qu'elles ne sont pas directement définies dans la balise ouvrante d'un élément donné.

Pour une instance MathML imbriquée dans un format de données textuelles (tel que HTML) en mode affichage, c'est-à-dire, à la place d'un paragraphe, les valeurs de l'expression la plus externe du code MathML imbriqué sont displaystyle="true" et scriptlevel="0" ; si le code MathML est imbriqué en mode direct, c'est-à-dire, à la place d'un caractère, les valeurs de l'expression la plus externe sont displaystyle="false" et scriptlevel="0". Cf. le chapitre 7 L'interface MathML pour d'autres explications à propos de la distinction entre les imbrications MathML affichées et directes et comment on peut les définir dans les instances particulières. En général, un moteur de rendu MathML peut déterminer ces valeurs initiales de quelque façon qui convienne pour l'emplacement et le contexte de l'instance spécifique MathML à rendre ou, s'il n'a aucun moyen de les déterminer, en fonction de la façon dont cette instance sera très probablement utilisée ; en dernier recours, on suggère d'utiliser les valeurs les plus génériques displaystyle="true" et scriptlevel="0".

Les schémas de disposition MathML qui affichent habituellement certains de leurs arguments dans un corps plus petit ou avec un espacement vertical moindre, à savoir les éléments d'écriture, les fractions, les radicaux et les tables ou matrices, fixent la valeur de l'attribut displaystyle à "false" et, dans certains cas, augmentent la valeur de l'attribut scriptlevel de ces arguments. Les nouvelles valeurs sont héritées, à moins d'être annulées, par toutes les sous-expressions dans ces arguments.

Les règles spécifiques selon lesquelles un élément modifie les attributs displaystyle et/ou scriptlevel sont données dans la définition de chaque élément concerné ; voici la liste complète des éléments qui modifient ces attributs : les éléments d'écriture msub, msup, msubsup, munder, mover, munderover et mmultiscripts et les éléments mfrac, mroot et mtable.

Lorsque l'élément mstyle reçoit un attribut scriptlevel sans signe, il fixe la valeur de l'attribut dans son contenu à celle donnée, laquelle doit être un entier non négatif. Lorsque la valeur de l'attribut se compose d'un signe suivi d'un entier, la valeur de scriptlevel est incrémentée (pour un signe +) ou décrémentée (pour un signe -) de la quantité indiquée. La syntaxe d'incrémentation de cet attribut constitue une exception aux règles générales de paramétrage des attributs hérités au moyen d'un élément mstyle, et tout autre attribut l'interdit sur l'élément mstyle.

À chaque fois où l'attribut scriptlevel change, soit automatiquement, soit explicitement par incrémentation, décrémentation ou définition, le corps de la police courante est multiplié par la valeur de l'attribut scriptsizemultiplier à la puissance du changement occasionné par scriptlevel. Par exemple, si l'attribut scriptlevel augmente de deux, le corps de la police est multipliée par scriptsizemultiplier, deux fois de suite ; si on fixe explicitement l'attribut scriptlevel à 2 alors qu'il était à 3, le corps de la police est divisé par la valeur de scriptsizemultiplier. Il faudrait comprendre les mentions de l'attribut fontsize dans cette section comme désignant soit l'attribut fontsize, soit l'attribut mathsize.

La valeur par défaut de l'attribut scriptsizemultiplier est inférieure à un (en fait, elle vaut approximativement racine carrée de 1/2), ce qui produit un corps de police inférieur lorsque la valeur de l'attribut scriptlevel augmente. Pour empêcher que l'écriture ne soit trop petite jusqu'à devenir illisible, le corps de la police n'est jamais autorisé à descendre sous la valeur de scriptminsize du fait d'un changement de l'attribut scriptlevel, quoiqu'on puisse lui fixer une valeur inférieure au moyen d'un attribut fontsize (cf. section 3.2.2 Les attributs de style mathématique communs des éléments atomiques) sur un élément mstyle ou sur des éléments atomiques. Si un changement de l'attribut scriptlevel devait aboutir à un corps de police inférieur à la valeur de l'attribut scriptminsize, en appliquant la formule précédente, le corps de la police prend plutôt une valeur égale à celle de l'attribut scriptminsize dans la sous-expression où l'attribut scriptlevel a changé.

Dans la syntaxe de l'attribut scriptminsize, la valeur v-unit représente une unité de longueur verticale (comme cela est décrit dans la section 2.4.4.2 Les attributs avec des unités). L'unité la plus courante pour indiquer le corps d'une police dans une composition est le point pt.

Les changements explicites de l'attribut fontsize n'ont aucun effet sur la valeur de l'attribut scriptlevel.

Autres précisions concernant l'attribut scriptlevel pour les moteurs de rendus

Pour les moteurs de rendu MathML gérant les feuilles de style CSS ou tout autre mécanisme de feuille de style analogue, les changements absolus ou relatifs de l'attribut fontsize (ou d'autres attributs) peuvent se produire implicitement sur n'importe quel élément en réponse à une feuille de style. Les changements de ce type de l'attribut fontsize n'ont aucun effet sur l'attribut scriptlevel. Un changement de l'attribut fontsize provoqué par une feuille de style annule l'attribut scriptminsize de la même façon qu'un changement explicite de l'attribut fontsize dans la balise ouvrante d'un élément (discuté précédemment), que la la feuille de style définisse le changement comme absolu ou bien relatif. (Par contre, tout changement suivant de l'attribut fontsize induit par l'attribut scriptlevel reste sous l'influence de la feuille de style). Comme l'impose CSS pour les attributs hérités, l'attribut fontsize modifié par la feuille de style est hérité par les éléments enfants.

Si un même élément est soumis au changement de son propre attribut fontsize, à la fois celui induit par une feuille de style et celui automatique (lié à l'attribut scriptlevel), c'est celui lié à l'attribut scriptlevel qui intervient d'abord ; en réalité, dans la mise en œuvre la plus simple des règles spécifiques de l'élément pour scriptlevel, ce changement sera effectué par le parent de l'élément au cours de la production des propriétés de rendu qu'il passe à l'élément en question, car c'est l'élément parent qui a connaissance du changement que devra subir ou non l'attribut scriptlevel de chacun de ses éléments enfants.

Si une feuille de style change le propre attribut fontsize de l'élément et si elle change aussi l'attribut scriptlevel (et donc l'attribut fontsize) de l'un de ses enfants, alors le changement induit par la feuille de style a lieu en premier suivi du changement hérité par cet enfant. Si les attributs scriptlevel de plusieurs enfants sont changés, le changement hérité par chaque enfant n'a aucun effet sur les autres enfants. (Comme règle mnémotechnique applicable à l'arbre d'analyse des éléments et leurs enfants, on peut associer les changements induits par une feuille de style sur l'attribut fontsize aux nœuds de l'arbre, c'est-à-dire aux éléments MathML, et associer les changements liés aux attributs scriptlevel aux arêtes entre l'élément parent et ses enfants ; ensuite, l'ordre des changements associés correspond à l'ordre des nœuds et des arêtes dans chaque cheminement en descendant l'arbre). Pour des informations plus générales à propos de l'ordre de traitement relatif des jeux de propriétés fixées par les feuilles de style par opposition à ceux fixés par les attributs, voir la sous-section appropriée dans la section 2.4.4.3 Les attributs compatibles avec CSS.

Si l'attribut scriptlevel est incrémenté par un élément mstyle qui fixe également d'autres attributs, l'effet global des changements dépendra peut-être de l'ordre où ils sont traités. Dans ces cas, on devrait traiter les attributs dans l'ordre de la liste suivante, indépendemment de celui où ils apparaissent dans la liste d'attributs au format XML de la balise ouvrante de l'élément mstyle : scriptsizemultiplier, scriptminsize, scriptlevel, fontsize.

Remarquez que l'attribut scriptlevel peut, en principes, prendre n'importe quelle valeur entière pourvu que la décrémentation soit suffisante, bien qu'on ne puisse fixer explicitement que des valeurs non négatives. Les valeurs négatives de l'attribut scriptlevel générées de cette façon sont légales et devraient fonctionner comme décrit, en générant des corps de police supérieurs à celui de l'expression environnante. Puisque la valeur initiale de l'attribut scriptlevel est "0" et qu'elle ne décroît jamais automatiquement, elle sera toujours non négative, à moins d'être décrémentée au-delà de "0" par un élément mstyle.

Les décréments explicites de l'attribut scriptlevel, après que l'attribut scriptminsize a limité le corps de la police comme décrit précédemment, produiraient des résultats indésirables. Cela peut être le cas, par exemple, dans la représentation d'une fraction continuée où l'attribut scriptlevel a été décrémenté sur une certaine partie du dénominateur en revenant à sa valeur pour la fraction dans son entier, si la fraction continuée en question se trouvait à une place dont la valeur scriptlevel était élevée. Pour empêcher ce problème, les moteurs de rendu devraient, pour une décrémentation de l'attribut scriptlevel, utiliser comme corps de police initial la valeur que ce corps aurait eu si l'attribut scriptminsize ne l'avait jamais limité. Par contre, ils ne devraient pas ignorer les effets de paramétrages explicites de l'attribut fontsize, même pour les valeurs inférieures à celle de l'attribut scriptminsize.

Puisque les moteurs de rendu MathML ne pourront pas toujours utiliser des corps de police arbitraires avec de bons résultats, ils modifieront peut-être la correspondance entre le niveau d'écriture et le corps de la police afin de produire, à leur avis, de meilleurs rendus. En particulier, pour ce qui est d'arrondir les corps de police aux valeurs disponibles, ou de les limiter à celles d'un intervalle, le déroulement de ces opérations dépendra du moteur de rendu. Toutefois, les moteurs de rendu devraient s'assurer qu'une succession de changements incrémentiels de l'attribut scriptlevel, qui ramèneraient à la même valeur de l'attribut dans une sous-expression que celle dans l'expression environnante, produise le même corps de police dans cette sous-expression que celui de l'expression environnante.

Les attributs de couleur et d'arrière-plan

Les attributs de couleur et d'arrière-plan sont abordés dans la section 3.2.2.2 Les attributs en relation avec la couleur.

La région précise de l'arrière-plan non définie

Les règles de rendu visuel suggéré MathML ne définissent pas l'étendue exacte de la région touchée par un attribut background utilisé sur l'élément mstyle, sauf que, si le contenu de mstyle n'avait aucune dimension négative et si la région de son dessin n'était pas recouverte par un autre dessin à cause d'un espacement environnant négatif, cette région devrait s'étaler derrière la totalité du dessin réalisé pour rendre le contenu de mstyle mais elle ne le devrait pas derrière des dessins réalisés pour rendre les expressions environnantes. Ces règles ne définissent pas l'effet du chevauchement des régions de dessin, provoqué par un espacement négatif, sur l'étendue de la région touchée par l'attribut background.

La signification des espaces mathématiques nommées

L'espacement entre les opérateurs correspond souvent à une valeur parmi très peu de valeurs potentielles. MathML nomme ces valeurs et permet de les changer. Puisque les valeurs d'espacement par défaut autour des opérateurs, décrites dans le dictionnaire d'opérateurs dans l'Annexe F Le dictionnaire d'opérateurs, sont définies d'après ces espaces nommées, changer leurs valeurs produira le resserrement ou le relâchement de l'espacement. On peut se servir de ces valeurs partout où des unités h-unit ou v-unit sont admises. Cf. la section 2.4.4.2 Les attributs avec des unités.

Les espaces nommées prédéfinies sont les suivantes : negativeveryverythinmathspace, negativeverythinmathspace, negativethinmathspace, negativemediummathspace, negativethickmathspace, negativeverythickmathspace, negativeveryverythickmathspace, veryverythinmathspace, verythinmathspace, thinmathspace, mediummathspace, thickmathspace, verythickmathspace et veryverythickmathspace. La progression des valeurs par défaut de veryverythinmathspace à veryverythickmathspace va de 1/18 em à 7/18 em.

3.3.4.3 Exemples

L'exemple illustrant la limitation de l'étirement d'une parenthèse dans la section traitant de l'élément <mo> :

<mrow>
   <mo maxsize="1"> ( </mo>
   <mfrac> <mi> a </mi> <mi> b </mi> </mfrac>
   <mo maxsize="1"> ) </mo>
</mrow>

On peut le récrire en se servant d'un élément mstyle de la façon suivante :

<mstyle maxsize="1">
   <mrow>
      <mo> ( </mo>
      <mfrac> <mi> a </mi> <mi> b </mi> </mfrac>
      <mo> ) </mo>
   </mrow>
</mstyle>

3.3.5 Les messages d'erreur (merror)

3.3.5.1 Description

L'élément merror affiche son contenu comme un message d'erreur. On pourrait le faire, par exemple, en affichant le contenu en rouge, en l'affichant par intermittence ou en changeant sa couleur d'arrière-plan. Le contenu peut être n'importe quelle expression ou séquence d'expressions.

L'élément merror accepte un nombre quelconque d'arguments ; si ce nombre est différent de un, son contenu est traité comme un seul élément mrow inféré, cf. la section 3.1.3 Les arguments obligatoires.

Cet élément constitue un moyen normalisé permettant aux programmes générant du code MathML d'après une autre entrée d'en signaler les erreurs de syntaxe. Puisque l'on prévoit le développement de préprocesseurs pour analyser des syntaxes d'entrée conçues pour une saisie manuelle aisée afin de générer du code MathML, il importe que ces préprocesseurs puissent signaler la présence d'une erreur de syntaxe à un certain point. Cf. la section 7.2.2 La gestion des erreurs.

L'emploi suggéré de l'élément merror pour un préprocesseur devant signaler les erreurs de syntaxe est de remplacer la partie erronnée de son entrée par un élément merror contenant une description de l'erreur, tout en poursuivant normalement le traitement des expressions environnantes tant que c'est possible. De cette façon, le message d'erreur sera rendu là où l'entrée erronnée aurait dû apparaître si elle avait été juste ; le travail de l'auteur pour déterminer d'après la sortie rendue quelle partie de l'entrée était erronnée s'en trouve facilité.

On ne suggère aucun format de message d'erreur spécifique ici mais, comme les messages d'erreur émis par tout programme, le format devrait être conçu de façon à exposer le plus clairement possible (au lecteur humain du message d'erreur rendu) ce qui était faux dans l'entrée et comment le réparer. Si l'entrée erronnée contient des sous-sections correctement formatées, il peut se révéler utile de les prétraiter normalement et de les inclure dans le message d'erreur (en contenu de l'élément merror), en tirant avantage de la capacité de l'élément merror à contenir des expressions MathML arbitraires au lieu d'afficher seulement un texte.

3.3.5.2 Attributs

Cet élément admet seulement les attributs id, xref, class et style, cf. la section 2.4.5 Les attributs communs à tous les éléments MathML.

3.3.5.3 Exemple

Si un préprocesseur au cours d'une vérification de syntaxe recevait en entrée l'expression suivante :

<mfraction>
   <mrow> <mn> 1 </mn> <mo> + </mo> <msqrt> <mn> 5 </mn> </msqrt> </mrow>
   <mn> 2 </mn>
</mfraction>

Comme elle contient un élément non MathML mfraction (probablement au lieu de l'élément MathML mfrac), le préprocesseur pourrait générer le message d'erreur suivant :

<merror>
   <mtext> Élément inconnu : mfraction ;
           arguments associés :  </mtext>
   <mrow> <mn> 1 </mn> <mo> + </mo> <msqrt> <mn> 5 </mn> </msqrt> </mrow>
   <mtext>  et  </mtext>
   <mn> 2 </mn>
</merror>

Remarquez que l'entrée du préprocesseur ici n'est pas un code MathML valide mais que le message d'erreur en sortie l'est.

3.3.6 L'ajustement de l'espace autour du contenu (mpadded)

3.3.6.1 Description

Un élément mpadded rend son contenu à l'identique mais sa dimension globale et d'autres dimensions (telle que la position de la ligne de base) sont modifiées conformément à ses attributs. L'élément mpadded ne réalise pas une nouvelle mise à l'échelle de son contenu (ne l'étire pas ni ne le retrécit) ; il a pour seul effet de modifier la dimension et la position apparente de la matrice autour de son contenu, et il agit donc sur le positionnement du contenu relativement aux éléments environnants. Le nom de l'élément reflète sa fonction qui est effectivement d'ajouter un espacement, ou espace supplémentaire, autour de son contenu. Si l'espacement est négatif, le contenu de l'élément mpadded sera peut-être rendu hors de sa matrice ; cf. les avertissements à suivre à propos de plusieurs pièges potentiels ayant cet effet.

L'élément mpadded accepte un nombre quelconque d'arguments ; si ce nombre est différent de un, son contenu est traité comme un seul élément mrow inféré, cf. la section 3.1.3 Les arguments obligatoires.

On suggère aux moteurs de rendu sonore d'ajouter des temporisations (ou de les raccourcir) selon les attributs représentant des espacements horizontaux (width et lspace).

3.3.6.2 Attributs

Outre les attributs listés ci-dessous, cet élément admet les attributs id, xref, class et style, cf. la section 2.4.5 Les attributs communs à tous les éléments MathML.

Nom Valeurs Valeur par défaut
width [ + | - ] unsigned-number ( % [ pseudo-unit ] | pseudo-unit | h-unit | namedspace ) pareille que le contenu
lspace [ + | - ] unsigned-number ( % [ pseudo-unit ] | pseudo-unit | h-unit ) 0
height [ + | - ] unsigned-number ( % [ pseudo-unit ] | pseudo-unit | v-unit ) pareille que le contenu
depth [ + | - ] unsigned-number ( % [ pseudo-unit ] | pseudo-unit | v-unit ) pareille que le contenu

(La description du symbole de syntaxe pseudo-unit suit).

Ces attributs modifient les dimensions de la matrice de l'élément mpadded. Les dimensions (qui ont les mêmes noms que les attributs) sont définies dans la sous-section suivante. Selon le format de la valeur de l'attribut, on peut fixer une nouvelle valeur à une dimension, ou lui attribuer la version incrémentée ou décrémentée de la dimension correspondante du contenu. On peut définir les valeurs comme multiples ou pourcentages de n'importe quelle dimension du rendu normal du contenu de l'élément (en se servant de pseudo-unités), ou les fixer directement en utilisant des unités normalisées (cf. la section 2.4.4.2 Les attributs avec des unités).

Si une valeur d'attribut commence par un signe + ou un signe -, celui-ci indique un incrément ou un décrément de la dimension correspondante par la valeur de longueur qui suit (cf. l'interprétation ci-dessous). Sinon la dimension correspondante prend directement la valeur de longueur qui suit. Remarquez que les caractères + et - ne signifient pas que la valeur suivante est positive ou négative, même si une unité de longueur explicite est fournie (h-unit ou v-unit). En particulier, ces attributs ne peuvent pas fixer directement de valeur négative à une dimension.

Les valeurs de longueur (après le signe optionnel qui ne fait pas partie de la valeur de longueur) peuvent être indiquées dans plusieurs formats. Chaque format commence par une valeur unsigned-number, qui peut être suivie par un signe % et une pseudo-unité (indiquée par pseudo-unit dans la syntaxe d'attribut précédente), par une pseudo-unité seule ou par une des unités de longueur (indiquées par h-unit ou v-unit) définies dans la section 2.4.4.2 Les attributs avec des unités, à l'exclusion du caractère %. Les pseudo-unités possibles sont les mots-clés width, lspace, height et depth ; chacun représente la longueur de la dimension de même nom du contenu de l'élément mpadded (pas de l'élément mpadded même). Les longueurs représentées par les valeurs h-unit et v-unit sont décrites dans la section 2.4.4.2 Les attributs avec des unités.

Dans chacun de ces formats, la valeur de longueur définie est le produit du nombre indiqué et de la longueur de l'unité ou de la pseudo-unité. Le résultat est multiplié par 0.01 si le caractère % est présent. Si aucune pseudo-unité n'est fournie après le caractère %, on suppose que c'est la pseudo-unité dont le nom est identique à celui de l'attribut à définir.

Voici quelques exemples de formats d'attribut utilisant des pseudo-unités (explicites ou par défaut) : les expressions depth="100% height" et depth="1.0 height" calquent toutes deux la profondeur de l'élément mpadded sur la hauteur de son contenu ; l'expression depth="105%" en fixe la profondeur à 1.05 fois celle du contenu ; les expressions depth="+100%" ou depth="200%" en fixent la profondeur à deux fois celle du contenu.

On ne peut pas rendre négatives des dimensions qui seraient positives si le contenu était rendu normalement en utilisant l'élément mpadded : une dimension positive est fixée à 0 si elle devait sinon devenir négative. On peut rendre négatives les dimensions initialement à 0 mais on devrait généralement l'éviter. Cf. les avertissements à propos de l'utilisation d'un espacement négatif pour déformer ou véhiculer une signification.

Les règles précédentes impliquent que tous les paramétrages d'attributs suivants produisent le même effet, à savoir laisser inchangées les dimensions du contenu :

<mpadded width="+0em"> ... </mpadded>
<mpadded width="+0%"> ... </mpadded>
<mpadded width="-0em"> ... </mpadded>
<mpadded width="- 0 height"> ... </mpadded>
<mpadded width="100%"> ... </mpadded>
<mpadded width="100% width"> ... </mpadded>
<mpadded width="1 width"> ... </mpadded>
<mpadded width="1.0 width"> ... </mpadded>
<mpadded> ... </mpadded>

3.3.6.3 Les significations des attributs de dimension

Cf. l'Annexe H Glossaire pour d'autres renseignements à propos des termes de composition employés ici.

L'attribut width désigne la largeur horizontale globale d'une matrice. Par défaut (c'est-à-dire, lorsque l'attribut lspace n'est pas modifié), la matrice du contenu d'un élément mpadded devrait être rendue de niveau avec le bord gauche de la matrice de l'élément mpadded. L'augmentation seule de l'attribut width ajoute donc effectivement de l'espace sur le bord droit de la boîte.

L'attribut lspace désigne la quantité d'espace entre le bord gauche d'une matrice et le début du rendu de la matrice de son contenu. À la différence des autres dimensions, l'attribut lspace ne correspond pas à la propriété réelle d'une matrice mais elle existe temporairement, seulement pendant les calculs effectués par chaque instance mpadded. Il permet d'ajouter de l'espace sur le bord gauche d'une matrice.

La justification derrière l'utilisation des attributs width et lspace pour contrôler l'espacement horizontal au lieu d'attributs plus symétriques, comme l'attribut lspace et un hypothétique rspace, est qu'il est préférable de disposer d'une pseudo-unité de largeur, en partie parce que width est une propriété de matrice réelle.

L'attribut height désigne la quantité d'espace vertical entre la ligne de base (la ligne courant en bas de la plupart des glyphes des lettres dans un rendu textuel normal) et le haut de la matrice.

L'attribut depth désigne la quantité d'espace vertical entre le bas de la matrice et la ligne de base.

Les moteurs de rendu MathML devraient s'assurer, hormis les effets des attributs, que l'espacement relatif entre le contenu de l'élément mpadded et les éléments MathML environnants ne change pas lorsqu'on remplace l'élément mpadded par un élément mrow ayant le même contenu. Cela reste vrai même si un saut de ligne advient au sein l'élément mpadded. Par contre, si un élément mpadded, dont les attributs n'ont pas de valeurs par défaut, est soumis à un saut de ligne, MathML ne définit pas comment ses attributs ou son rendu se comportent vis-à-vis de l'algorithme de saut de ligne.

3.3.6.4 Attention : la non-portabilité d'une déformation

Un auteur sera vraisemblablement tenté d'utiliser les éléments mpadded et mspace (et peut-être aussi les éléments mphantom et mtext) pour ajuster l'espacement généré par un moteur de rendu spécifique en le modifiant légèrement dans certaines expressions, c'est-à-dire, de déformer le rendu.

Les auteurs sont fortement mis en garde de ce que les divers moteurs de rendu MathML sont susceptibles d'utiliser des règles différentes d'espacement pour calculer les positions relatives des symboles rendus dans des expressions dont l'espacement n'est pas modifié explicitement ; si un moteur de rendu B a de meilleures règles d'espacement que le moteur de rendu A, l'ajout d'un espacement explicite afin améliorer la qualité de la sortie du moteur de rendu A peut se traduire par un résultat très mauvais avec B, probablement pire que sans déformation du tout.

Même si on peut supposer un choix spécifique par le moteur de rendu, ses règles d'espacement sont susceptibles d'amélioration au fur et à mesure des versions, et l'effet d'une déformation dans un document MathML donné pourra donc empirer avec le temps. Également, lorsque des mécanismes de feuille de style s'appliqueront à MathML, une version d'un moteur de rendu pourra même utiliser des règles différentes d'espacement pour les utilisateurs ayant des feuilles de style différentes.

On suggère donc de ne jamais utiliser les éléments mpadded ou mspace dans un balisage MathML pour déformer le rendu d'expressions spécifiques, à moins que le code MathML généré ne doive uniquement être visualisé sur une version spécifique d'un moteur de rendu MathML et, si ce moteur de rendu gère les feuilles de style, en utilisant une seule feuille de style spécifique.

Au cas où la tentation d'améliorer l'espacement serait trop forte, un recours précautionneux aux éléments mpadded, mphantom ou aux éléments d'alignement (cf. la section 3.5.5 Les marqueurs d'alignement) donnera peut-être des résultats plus portables que l'insertion directe d'un espace supplémentaire à l'aide d'un élément mspace ou mtext. Les conseils donnés aux développeurs de moteurs de rendu MathML se révéleront peut-être plus productifs encore à long terme.

3.3.6.5 Attention : on ne devrait pas utiliser d'espacements pour véhiculer une signification

Les éléments MathML admettant un espacement négatif, à savoir les éléments mspace, mpadded et mtext, pourraient théoriquement servir à simuler de nouvelles notations ou des caractères en surimpression par recouvrement visuel des rendus de plusieurs sous-expressions MathML.

Cette pratique est fortement déconseillée dans tous les cas pour les raisons suivantes :

Plus généralement, on déconseille toute construction recourant à un espacement pour véhiculer une signification mathématique, plutôt que simplement comme aide à visualiser la structure d'une expression. C'est-à-dire, les constructions déconseillées sont celles que le lecteur humain d'un code MathML rendu interpréterait différemment si on avait retiré tous les espacements explicites.

Si, en dépit de cet avertissement, de telles constructions étaient utilisées, on devrait les englober dans un élément semantics qui fournit également une expression MathML supplémentaire à interpréter de façon normale.

Par exemple, l'expression MathML :

<mrow>
  <mpadded width="0"> <mi> C </mi> </mpadded>
  <mspace width="0.3em"/>
  <mtext> | </mtext>
</mrow>

Cette expression forme un symbole en surimpression, en contradiction avec la politique déclarée précédemment ; elle pourrait servir à représenter l'ensemble des nombres complexes pour un moteur de rendu MathML ne disposant pas du symbole normalisé employé pour cet usage. On devrait toujours éviter ce type de construction dans MathML, pour les raisons invoquées ci-dessus ; en effet, cette construction ne devrait jamais être nécessaire pour les symboles normalisés, puisque un moteur de rendu MathML sans une meilleure méthode pour les rendre est libre de recourir à une surimpression interne, et il pourra donc toujours gérer une entrée MathML normalisée.

Quoi qu'il en soit, si on utilise une telle construction dans MathML, on devrait toujours l'englober dans un élément semantics comme suit :

<semantics>
  <mrow>
    <mpadded width="0"> <mi> C </mi> </mpadded>
    <mspace width="0.3em"/>
    <mtext> | </mtext>
  </mrow>
  <annotation-xml encoding="MathML-Presentation">
    <mi> &Copf; </mi>
  </annotation-xml>
</semantics>

Cette expression fournit un autre codage normalisé pour le symbole souhaité qui s'interprète bien plus facilement que la construction utilisant un espacement négatif. (Dans cet exemple, le codage alternatif emploie des éléments de présentation MathML ; on devrait aussi considérer les éléments de contenu décrits dans le chapitre 4 Le balisage de contenu).

(L'avertissement précédent s'applique également à la plupart des utilisations d'attributs de rendu pour altérer la signification véhiculée par une expression, à l'exception des attributs de l'élément mi, tel que fontweight, qui servent à distinguer une variable d'une autre).

3.3.7 Rendre invisible les sous-expressions (mphantom)

3.3.7.1 Description

Le rendu de l'élément mphantom est invisible mais avec la même dimension et les autres mesures, y compris la position de la ligne de base, que son contenu s'il avait été rendu normalement. L'élément mphantom peut servir à aligner des parties d'une expression en dupliquant des sous-expressions de manière invisible.

L'élément mphantom accepte un nombre quelconque d'arguments ; si ce nombre est différent de 1, son contenu est traité comme un seul élément mrow inféré formé par tous ses arguments, cf. la section 3.1.3 Les arguments obligatoires.

3.3.7.2 Attributs

Cet élément admet seulement les attributs id, xref, class et style, cf la section 2.4.5 Les attributs communs à tous les éléments MathML.

Remarquez qu'on peut envelopper une expression MathML avec un élément mphantom et un élément mpadded, tel que dans <mphantom><mpadded paramétrages d'attributs> ... </mpadded></mphantom>, pour en même temps changer sa dimension et la rendre invisible.

Les moteurs de rendu MathML devraient s'assurer que l'espacement relatif entre le contenu d'un élément mphantom et les éléments MathML environnants soit identique à celui qu'il serait si l'élément mphantom était remplacé par un élément mrow avec le même contenu. Cela reste vrai même si un saut de ligne advient dans l'élément mphantom.

Pour cette raison, l'élément mphantom n'est pas assimilé à un élément pareil à un espace (cf. section 3.2.7 L'espacement (mspace)), sauf si son contenu est pareil à un espace, puisque les règles de rendu suggéré des opérateurs changent selon que les éléments voisins sont ou non pareils à des espaces. Et même dans ce cas, l'avertissement à propos du regroupement légal des éléments pareils à des espaces peut s'appliquer aux utilisations de l'élément mphantom.

La règle précédente pour le rendu d'un élément mphantom ne donnera peut-être pas le résultat voulu dans une situation. Lorsqu'un élément mphantom entoure une sous-séquence d'arguments d'un élément mrow, la détermination de l'attribut form par défaut d'un élément mo dans la sous-séquence peut changer. (Cf. la valeur par défaut de l'attribut form décrite dans la section 3.2.5 Les opérateurs, les délimiteurs, les séparateurs ou les accents (mo)). Auquel cas, il peut se révéler nécessaire d'ajouter un attribut form explicite à cet élément mo. En voir l'illustration dans l'exemple suivant.

3.3.7.3 Exemples

Dans cet exemple, l'élément mphantom sert à garantir l'alignement des parties correspondantes du numérateur et du dénominateur d'une fraction :

<mfrac>
  <mrow>
    <mi> x </mi>
    <mo> + </mo>
    <mi> y </mi>
    <mo> + </mo>
    <mi> z </mi>
  </mrow>
  <mrow>
    <mi> x </mi>
    <mphantom>
      <mo form="infix"> + </mo>
      <mi> y </mi>
    </mphantom>
    <mo> + </mo>
    <mi> z </mi>
  </mrow>
</mfrac>

Le rendu serait celui-ci :

\frac{x+y+z}{x\phantom{+y}\;+z}

Plutôt que celui-là :

\frac{x+y+z}{x+z}

Le paramétrage d'attribut explicite form="infix" sur l'élément mo dans l'élément mphantom fixe l'attribut form à la valeur qui aurait été la sienne en l'absence de l'élément mphantom environnant. Cette déclaration est nécessaire car sinon le signe + serait interprété comme un opérateur préfixe qui aurait un espacement légèrement différent.

Autrement, on aurait pu éviter ce problème, sans paramétrage d'attribut explicite, en enveloppant chacun des arguments <mo>+</mo> et <mi>y</mi> dans un élément mphantom propre comme suit :

<mfrac>
   <mrow>
      <mi> x </mi>
      <mo> + </mo>
      <mi> y </mi>
      <mo> + </mo>
      <mi> z </mi>
   </mrow>
   <mrow>
      <mi> x </mi>
      <mphantom>
         <mo> + </mo>
      </mphantom>
      <mphantom>
         <mi> y </mi>
      </mphantom>
      <mo> + </mo>
      <mi> z </mi>
   </mrow>
</mfrac>

3.3.8 Les expressions entre une paire de délimiteurs (mfenced)

3.3.8.1 Description

L'élément mfenced offre une forme commode qui permet d'exprimer des constructions communes impliquant des délimiteurs (c.à.d., des accolades, des crochets et des parenthèses), comprenant éventuellement des séparateurs (telles que des virgules) entre les arguments.

Par exemple, l'expression <mfenced> <mi>x</mi> </mfenced>, rendue par (x), équivaut à :

<mrow> <mo> ( </mo> <mi>x</mi> <mo> ) </mo> </mrow>

Et l'expression : <mfenced> <mi>x</mi> <mi>y</mi> </mfenced>, rendue par (xy), équivaut à :

<mrow>
  <mo> ( </mo>
  <mrow> <mi>x</mi> <mo>,</mo> <mi>y</mi> </mrow>
  <mo> ) </mo>
</mrow>

Les délimiteurs ou les séparateurs individuels sont représentés en recourant à des éléments mo, cf. la section 3.2.5 Les opérateurs, les délimiteurs, les séparateurs ou les accents (mo). Ainsi, tout élément mfenced équivaut entièrement à une forme dont la description suit ; on peut utiliser l'une ou l'autre forme en MathML, selon qu'elle convient à l'auteur ou au programme de génération MathML. Un moteur de rendu MathML est tenu de rendre l'une et l'autre formes exactement de la même façon.

En général, un élément mfenced contiendra zéro à plusieurs arguments qu'il englobera entre des délimiteurs dans un élément mrow ; s'il y a plusieurs arguments, il insérera des séparateurs entre les arguments adjacents, en recourant à un élément mrow imbriqué supplémentaire autour des arguments et des séparateurs pour leur bon regroupement (cf. section 3.3.1 Le regroupement horizontal des sous-expressions (mrow)). On montre la forme générale développée ci-dessous. Les délimiteurs et les séparateurs seront, par défaut, des parenthèses et des virgules mais on peut les changer en recourant à des attributs, comme indiqué dans le tableau suivant.

3.3.8.2 Attributs

Outre les attributs listés ci-dessous, cet élément admet les attributs id, xref, class et style, cf. la section 2.4.5 Les attributs communs à tous les éléments MathML.

Nom Valeurs Valeur par défaut
open string (
close string )
separators character * ,

Un élément mfenced générique dont tous les attributs sont explicites ressemble à ceci :

<mfenced open="délimiteur-ouvrant"
         close="délimiteur-fermant"
         separators="sep#1 sep#2 ... sep#(n-1)" >
   arg#1
   ...
   arg#n
</mfenced>

Les valeurs délimiteur-ouvrant et délimiteur-fermant sont des chaînes arbitraires. (Puisque ces valeurs sont utilisées comme contenu d'éléments mo, tous les blancs qu'elles contiennent seront rognés et rétractés, cf. la section 2.4.6 La rétractation des blancs en entrée).

La valeur de l'attribut separators est une séquence de zéro à plusieurs caractères de séparation (ou références d'entité), avec des blancs intermédiaires en option. Chaque valeur sep#i se compose d'un seul caractère (ou référence d'entité) exactement. Ainsi, l'expression separators=",;" équivaut à separators=" , ; ".

L'élément mfenced générique (cf. ci-dessus) équivaut aux formes développées suivantes :

<mrow>
   <mo fence="true"> délimiteur-ouvrant </mo>
   <mrow>
      arg#1
      <mo separator="true"> sep#1 </mo>
      ...
      <mo separator="true"> sep#(n-1) </mo>
      arg#n
   </mrow>
   <mo fence="true"> délimiteur-fermant </mo>
</mrow>

Chaque argument, sauf le dernier, est suivi par un séparateur. L'élément mrow est ajouté pour un bon regroupement, cf. la section 3.3.1 Le regroupement horizontal des sous-expressions (mrow).

Lorsqu'il n'y a qu'un seul argument, la forme précédente n'a pas de séparateur ; comme l'expression <mrow> arg#1 </mrow> équivaut à arg#1 (cf. la section 3.3.1 Le regroupement horizontal des sous-expressions (mrow)), ce cas équivant aussi à :

<mrow>
   <mo fence="true"> délimiteur-ouvrant </mo>
   arg#1
   <mo fence="true"> délimiteur-fermant </mo>
</mrow>

S'il y a beaucoup trop de caractères séparateurs, ceux en trop sont ignorés. Si des caractères séparateurs sont fournis mais qu'il n'y en a pas assez, le dernier est répété si besoin. Ainsi, la valeur par défaut de separators="," équivaut à separators=",,", separators=",,,", etc. Si aucun caractère séparateur n'est fourni mais qu'il en faut un, par exemple, lorsque separators=" " ou separators="", et s'il y a plusieurs arguments, alors aucun élément séparateur n'est inséré du tout, c'est-à-dire que les éléments <mo separator="true"> sep#i </mo> sont entièment abandonnés. Remarquez que ce n'est pas la même chose que l'insertion de séparateurs composés d'éléments mo avec un contenu vide.

Finalement, en cas d'absence d'argument, c'est-à-dire :

<mfenced open="délimiteur-ouvrant"
         close="délimiteur-fermant"
         separators="quoi que ce soit" >
</mfenced>

La forme développée développée est définie pour ne contenir que les délimiteurs dans un élément mrow :

<mrow>
   <mo fence="true"> délimiteur-ouvrant </mo>
   <mo fence="true"> délimiteur-fermant </mo>
</mrow>

Remarquez que les expressions délimitées ne peuvent pas toutes être codées par un élément mfenced. Ces expressions exceptionnelles comprennent celles avec un séparateur ou un délimiteur embellis ou l'une englobée dans un élément mstyle, celles avec un séparateur ou un délimiteur manquants ou en trop ou celles avec un séparateur composé de plusieurs caractères de contenu. Dans ces cas, il est nécessaire de coder l'expression en recourant à une version convenablement modifiée d'une forme développée. Comme expliqué précédemment, on peut toujours utiliser directement la forme développée, même lorsqu'elle n'est pas nécessaire. En particulier, les auteurs n'ont aucune garantie que les préprocesseurs MathML ne remplaceront pas les occurences de mfenced par les formes développées équivalentes.

Remarquez que les formes développées équivalentes exposées précédemment comprennent des attributs sur les éléments mo qui les identifient comme délimiteurs ou séparateurs. Dans la mesure où les choix de délimiteurs et de séparateurs les plus courants apparaissent déjà dans le dictionnaire d'opérateurs avec ces attributs, les auteurs n'ont normalement pas besoin de définir ces attributs explicitement lorsqu'ils utilisent directement la forme développée. Également, les règles par défaut de l'attribut form (cf. section 3.2.5 Les opérateurs, les délimiteurs, les séparateurs ou les accents (mo)) font que les délimiteurs ouvrant et fermant reçoivent en fait, respectivement, les valeurs form="prefix" et form="postfix", et les séparateurs la valeur form="infix".

Remarquez qu'il ne serait pas correct d'utiliser un élément avec le séparateur +, par exemple, comme abréviation pour une expression utilisant + en tant qu'opérateur ordinaire :

<mrow>
  <mi>x</mi> <mo>+</mo> <mi>y</mi> <mo>+</mo> <mi>z</mi>
</mrow>

Car les signes + seraient traités comme des séparateurs, et non comme des opérateurs infixes. C'est-à-dire qu'ils seraient rendus comme s'ils étaient balisés par <mo separator="true">+</mo>, et donc rendus de façon inapproprié.

3.3.8.3 Exemples

(a+b)

<mfenced>
  <mrow>
    <mi> a </mi>
    <mo> + </mo>
    <mi> b </mi>
  </mrow>
</mfenced>

Remarquez que l'élément mrow ci-dessus est nécessaire pour que l'élément mfenced n'ait qu'un seul argument. Sans lui, l'expression aurait été rendue incorrectement par (a, +, b).

[0,1)

<mfenced open="[">
  <mn> 0 </mn>
  <mn> 1 </mn>
</mfenced>

f(x,y)

<mrow>
  <mi> f </mi>
  <mo> &ApplyFunction; </mo>
  <mfenced>
    <mi> x </mi>
    <mi> y </mi>
  </mfenced>
</mrow>

3.3.9 L'inclusion d'une expression dans une notation (menclose)

3.3.9.1 Description

L'élément menclose rend son contenu dans la notation englobante définie par son attribut notation. L'élément menclose accepte un nombre quelconque d'arguments ; si ce nombre est différent de 1, son contenu est traité comme un seul élément mrow inféré contenant ses arguments, cf. la section 3.1.3 Les arguments obligatoires.

3.3.9.2 Attributs

Outre les attributs listés ci-dessous, cet élément admet les attributs id, xref, class et style, cf. la section 2.4.5 Les attributs communs à tous les éléments MathML.

Nom Valeurs Valeur par défaut
notation longdiv | actuarial | radical longdiv

Lorsque l'attribut notation a la valeur "longdiv", le contenu est dessiné englobé par un symbole de division long. On peut également obtenir un exemple complet de division longue en utilisant des éléments mtable et malign. Lorsque l'attribut notation a la valeur "actuarial", le contenu est dessiné englobé par un symbole actuariel. En ce qui concerne la valeur notation="radical", elle équivaut au schéma de l'élément msqrt.

3.3.9.3 Exemples

On pourrait utiliser le balisage suivant afin de coder un problème élémentaire à division longue dans le style américain :

<mtable columnspacing='0pt' rowspacing='0pt'>
<mtr>
  <mtd></mtd>
  <mtd columnalign='right'><mn>10</mn></mtd>
</mtr>
<mtr>
  <mtd columnalign='right'><mn>131</mn></mtd>
  <mtd columnalign='right'>
    <menclose notation='longdiv'><mn>1413</mn></menclose>
  </mtd>
</mtr>
<mtr>
  <mtd></mtd>
  <mtd columnalign='right'>
    <mrow>
    <munder>
      <mn>131</mn>
      <mo> &UnderBar; </mo>
    </munder>
    <mphantom><mn>3</mn></mphantom>
    </mrow>
  </mtd>
</mtr>
<mtr>
  <mtd></mtd>
  <mtd columnalign='right'><mn>103</mn></mtd>
</mtr>
</mtable>

Ce qui donnerait à peu près ceci :

\begin{array}{rl} & \phantom{)14}10 \\ 131 & \overline{)1413\,} \\ & \phantom{)}\underline{131\phantom{g}} \\ & \phantom{)1}103 \end{array}

Voici un exemple d'utilisation de l'élément menclose pour une notation actuarielle :

<msub>
  <mi>a</mi>
  <mrow>
    <menclose notation='actuarial'>
      <mi>n</mi>
    </menclose>
    <mo>&it;</mo>
    <mi>i</mi>
  </mrow>
</msub>

Dont le rendu est à peu près le suivant :

\begin{array}{l@{}l} \phantom{x}a & \\ \overline{\phantom{x}n\phantom{|}}| & i \end{array}

3.4 Les schémas d'écritures et de limites

Les éléments décrits dans cette section positionnent une ou plusieurs écritures autour d'une base. L'accolement de types d'écritures et d'embellissements variés aux symboles constitue un appareil de notation très courant en mathématiques. Dans une disposition purement visuelle, un seul élément d'usage général suffirait pour positionner les écritures et les embellissements aux emplacements traditionnels d'écriture autour d'une certaine base. Néanmoins, MathML fournit plusieurs éléments d'écriture plus spécialisés afin de mieux restituer la structure abstraite de la notation courante.

Outre les éléments en indice ou en exposant, MathML offre des éléments d'écriture dessus et dessous qui placent les écritures au-dessus et en-dessous de la base. Ces éléments peuvent servir à placer des limites sur des opérateurs larges ou à placer des accents et des lignes au-dessus ou en-dessous de la base. Les règles de rendu des accents diffèrent de celles des exposants et des indices, et on peut nuancer ces différences avec les attributs accent et accentunder, décrits dans les sections concernées à suivre.

Le rendu des écritures est affecté par les attributs scriptlevel et displaystyle, qui font partie de l'environnement hérité par le processus de rendu de chaque expression MathML et qui sont décrites dans la section traitant de l'élément mstyle (section 3.3.4 Les changements de style (mstyle)). Ces attributs ne peuvent pas apparaître explicitement sur un élément d'écriture, mais on peut les spécifier dans la balise ouvrante d'un élément mstyle environnant si on le souhaite.

MathML fournit également un élément pour accoler des indices tensoriels. Les indices tensoriels se distinguent des indices et des exposants ordinaires en cela qu'ils doivent s'aligner dans des colonnes verticales. Ils peuvent aussi advenir en position de préécriture.

Parce qu'on devrait utiliser des éléments de présentation pour décrire la structure de notation abstraite des expressions, il importe que l'expression de base dans tous les éléments d'écriture (c.à.d., l'expression du premier argument) soit l'expression entière à écrire, et non pas juste le caractère le plus à droite. Par exemple, l'expression (x+y)2 devrait s'écrire :

<msup>
  <mrow>
    <mo> ( </mo>
    <mrow>
      <mi> x </mi>
      <mo> + </mo>
      <mi> y </mi>
    </mrow>
    <mo> ) </mo>
  </mrow>
  <mn> 2 </mn>
</msup>

3.4.1 L'écriture en indice inférieur (msub)

3.4.1.1 Description

La syntaxe de l'élément msub est la suivante :

<msub> base indice </msub>

3.4.1.2 Attributs

Outre les attributs listés ci-dessous, cet élément admet les attributs id, xref, class et style, comme décrit dans la section 2.4.5 Les attributs communs à tous les éléments MathML.

Nom Valeurs Valeur par défaut
subscriptshift number v-unit automatique (l'unité typique est le ex)

L'attribut subscriptshift indique la quantité minimum du glissement de la ligne de base de l'argument indice vers le bas.

La valeur v-unit représente une unité de longueur verticale (cf. la section 2.4.4.2 Les attributs avec des unités).

L'élément msub incrémente la valeur de l'attribut scriptlevel de 1 et règle celle de l'attribut displaystyle à false, pour l'argument indice, mais laisse les deux attributs inchangés pour l'argument base. (Chaque élément hérite ces attributs au travers de son environnement de rendu, mais on ne peut les définir explicitement que sur l'élément mstyle (cf. la section 3.3.4 Les changements de style (mstyle)).

3.4.2 L'écriture en exposant (msup)

3.4.2.1 Description

La syntaxe de l'élément msup est la suivante :

<msup> base exposant </msup>

3.4.2.2 Attributs

Outre les attributs listés ci-dessous, cet élément admet les attributs id, xref, class et style, comme décrit dans la section 2.4.5 Les attributs communs à tous les éléments MathML.

Nom Valeurs Valeur par défaut
superscriptshift number v-unit automatique (l'unité typique est le ex)

L'attribut superscriptshift indique la quantité minimum du glissement de la ligne de base de l'argument exposant vers le haut.

La valeur v-unit représente une unité de longueur verticale (cf. la section 2.4.4.2 Les attributs avec des unités).

L'élément msup incrémente la valeur de l'attribut scriptlevel de 1 et règle celle de l'attribut displaystyle à false, pour l'argument exposant, mais laisse les deux attributs inchangés pour l'argument base. (Chaque élément hérite ces éléments au travers de son environnement de rendu, mais on ne peut les définir explicitement que sur l'élément mstyle [cf. la section 3.3.4 Les changements de style (mstyle)].)

3.4.3 Les paires indice-exposant (msubsup)

3.4.3.1 Description

L'élément msubsup sert à accoler à la fois un indice et un exposant à une expression de base. Remarquez que les deux écritures sont positionnées serrées contre la base : x_1{}^2 à comparer à x_1^2.

La syntaxe de l'élément msubsup est la suivante :

<msubsup> base indice exposant </msubsup>

3.4.3.2 Attributes

Outre les attributs listés ci-dessous, cet élément admet les attributs id, xref, class et style, comme décrit dans la section 2.4.5 Les attributs communs à tous les éléments MathML.

Nom Valeurs Valeur par défaut
subscriptshift number v-unit automatique (l'unité typique est le ex)
superscriptshift number v-unit automatique (l'unité typique est le ex)

L'attribut subscriptshift indique la quantité minimum du glissement de la ligne de base de l'argument indice vers le bas et l'attribut superscriptshift la quantité minimum du glissement de la ligne de base de l'argument exposant vers le haut.

La valeur v-unit représente une unité de longueur verticale (cf. la section 2.4.4.2 Les attributs avec des unités).

L'élément msubsup incrémente la valeur de l'attribut scriptlevel de 1 et règle la valeur de l'attribut displaystyle à false, pour les arguments indice et exposant, mais laisse les deux attributs inchangés pour l'argument base. (Chaque élément hérite ces attributs au travers de son environnement de rendu, mais on ne peut les définir explicitement que sur l'élément mstyle (cf. la section 3.3.4 Les changements de style (mstyle)).

3.4.3.3 Exemples

L'élément msubsup est utilisé le plus souvent pour ajouter des paires indice-exposant aux identifiants, comme illustré précédemment. Toutefois, un autre usage important est le placement de limites sur certains opérateurs larges où elles s'affichent traditionnellement aux positions des écritures, même pour un rendu dans le style de l'affichage. L'usage le plus courant en est l'intégrale. Par exemple, l'expression :

\int\nolimits_0^1 \eulere^x \,\diffd x

Qui serait représentée par :

<mrow>
  <msubsup>
    <mo> &int; </mo>
    <mn> 0 </mn>
    <mn> 1 </mn>
  </msubsup>
  <mrow>
    <msup>
      <mi> &ExponentialE; </mi>
      <mi> x </mi>
    </msup>
    <mo> &InvisibleTimes; </mo>
    <mrow>
      <mo> &DifferentialD; </mo>
      <mi> x </mi>
    </mrow>
  </mrow>
</mrow>

3.4.4 L'écriture dessous (munder)

3.4.4.1 Description

La syntaxe de l'élément munder est la suivante :

<munder> base dessous </munder>

3.4.4.2 Attributs

Outre les attributs listés ci-dessous, cet élément admet les attributs id, xref, class et style, comme décrit dans la section 2.4.5 Les attributs communs à tous les éléments MathML.

Nom Valeurs Valeur par défaut
accentunder true | false automatique

L'attribut accentunder contrôle si l'argument dessous est dessiné comme un accent ou comme une limite. La différence principale entre un accent et une limite est que la dimension de la limite est réduite tandis que la dimension de l'accent est la même que celle de la base. Une seconde différence est que l'accent est dessiné plus près de la base.

La valeur par défaut de l'attribut accentunder est false, à moins que l'argument dessous ne soit un élément mo ou un opérateur embelli (cf. la section 3.2.5 Les opérateurs, les délimiteurs, les séparateurs ou les accents (mo)). Si l'argument dessous est un élément mo, alors la valeur de son attribut accent sert de valeur par défaut pour l'attribut accentunder. Si l'argument dessous est un opérateur embelli, l'attribut accent de l'élément mo nu sert alors de valeur par défaut. Comme pour tous les attributs, une valeur explicite surclasse celle par défaut.

Voici un exemple (accent contre écriture dessous) : \underbrace{x+y+z} à comparer à \underbrace{\strut x+y+z}. La représentation MathML de cet exemple est montrée ci-dessous.

Si la base est un opérateur défini avec les attributs movablelimits="true" (ou un opérateur embelli dont l'élément mo nu est défini avec l'attribut movablelimits="true") et displaystyle="false", alors l'argument dessous est dessiné en position d'indice inférieur. Dans ce cas, l'attribut accentunder est ignoré. Ceci est souvent employé pour les limites sur des symboles, tel que celui de somme &sum;.

Pour l'argument dessous, l'élément munder règle toujours l'attribut displaystyle sur la valeur false, mais il incrémente la valeur de l'attribut scriptlevel de 1 seulement quand l'attribut accentunder a la valeur false. Pour l'argument base, il laisse toujours les deux attributs inchangés. (Chaque élément hérite ces attributs au travers de son environnement de rendu, mais on ne peut les définir explicitement que sur l'élément mstyle [cf. la section 3.3.4 Les changements de style (mstyle)].)

3.4.4.3 Exemples

La représentation MathML de l'exemple précédent est la suivante :

<mrow>
  <munder accentunder="true">
    <mrow>
      <mi> x </mi>
      <mo> + </mo>
      <mi> y </mi>
      <mo> + </mo>
      <mi> z </mi>
    </mrow>
    <mo> &UnderBrace; </mo>
  </munder>
  <mtext>&nbsp;à comparer à&nbsp;</mtext>
  <munder accentunder="false">
    <mrow>
      <mi> x </mi>
      <mo> + </mo>
      <mi> y </mi>
      <mo> + </mo>
      <mi> z </mi>
    </mrow>
    <mo> &UnderBrace; </mo>
  </munder>
</mrow>

3.4.5 L'écriture dessus (mover)

3.4.5.1 Description

La syntaxe de l'élément mover est la suivante :

<mover> base dessus </mover>

3.4.5.2 Attributs

Outre les attributs listés ci-dessous, cet élément admet les attributs id, xref, class et style, comme décrit dans la section 2.4.5 Les attributs communs à tous les éléments MathML.

Nom Valeurs Valeur par défaut
accent true | false automatique

L'attribut accent contrôle si l'argument dessus est dessiné comme un accent (marque diacritique) ou comme une limite. La différence principale entre un accent et une limite est que la dimension de la limite est réduite tandis que la dimension de l'accent est la même que celle de la base. Une seconde différence est que l'accent est dessiné plus près de la base. Ceci est illustré ci-dessous (accent contre limite) : \hat{x} à comparer à \hat{\strut x}.

Ces différences s'appliquent également aux accents mathématiques telles que les barres au-dessus des expressions : \overbrace{x+y+z} à comparer à \overbrace{\strut x+y+z}. La représentation MathML de chacun de ces exemples est donnée ci-dessous.

La valeur par défaut de l'attribut accent est "false", à moins que l'argument dessus ne soit un élément mo ou un opérateur embelli (cf. la section 3.2.5 Les opérateurs, les délimiteurs, les séparateurs ou les accents (mo)). Si l'argument dessus est un élément mo, alors la valeur de son attribut accent sert de valeur par défaut pour l'attribut accent de l'élément mover. Si l'argument dessus est un opérateur embelli, l'attribut accent de l'élément mo nu sert alors de valeur par défaut.

Si la base est un opérateur défini avec les attributs movablelimits="true" (ou un opérateur embelli dont l'élément mo nu est défini avec l'attribut movablelimits="true") et displaystyle="false", alors l'argument dessus est dessiné en position d'exposant. Dans ce cas, l'attribut accent est ignoré. Ceci est souvent employé pour les limites sur des symboles, tel que celui de somme &sum;.

Pour l'argument dessus, l'élément mover règle toujours l'attribut displaystyle à "false", mais il incrémente la valeur de l'attribut scriptlevel de 1 seulement quand la valeur de l'attribut accent est "false". Pour l'argument base, il laisse toujours les deux attributs inchangés. (Chaque élément hérite ces attributs au travers de son environnement de rendu, mais on ne peut les définir explicitement que sur l'élément mstyle [cf. la section 3.3.4 Les changements de style (mstyle)].)

3.4.5.3 Exemples

La représentation MathML des exemples montrés précédemment est la suivante :

<mrow>
  <mover accent="true">
    <mi> x </mi>
    <mo> &Hat; </mo>
  </mover>
  <mtext> à comparer à </mtext>
  <mover accent="false">
    <mi> x </mi>
    <mo> &Hat; </mo>
  </mover>
</mrow>
<mrow>
  <mover accent="true">
    <mrow>
      <mi> x </mi>
      <mo> + </mo>
      <mi> y </mi>
      <mo> + </mo>
      <mi> z </mi>
    </mrow>
    <mo> &OverBar; </mo>
  </mover>
  <mtext> à comparer à </mtext>
  <mover accent="false">
    <mrow>
      <mi> x </mi>
      <mo> + </mo>
      <mi> y </mi>
      <mo> + </mo>
      <mi> z </mi>
    </mrow>
    <mo> &OverBar; </mo>
  </mover>
</mrow>

3.4.6 Les paires dessous-dessus (munderover)

3.4.6.1 Description

La syntaxe de l'élément munderover est la suivante :

<munderover> base underscript overscript </munderover>

3.4.6.2 Attributs

Outre les attributs listés ci-dessous, cet élément admet les attributs id, xref, class et style, comme décrit dans la section 2.4.5 Les attributs communs à tous les éléments MathML.

Nom Valeurs Valeur par défaut
accent true | false automatique
accentunder true | false automatique

L'élément munderover sert à espacer l'écriture dessous et l'écriture dessus de façon équidistante de la base dans le sens vertical et de façon à suivre son inclinaison, comme dans la seconde expression ci-dessous :

\int_0^{\!\!\!\infty}

à comparer à

\int_0^{\infty}

La représentation MathML de cet exemple est donnée ci-dessous.

La différence d'espacement vertical est trop faible pour être remarquée dans un affichage en basse résolution et dans une taille de police normale, mais elle est visible avec un appareil en haute résolution telle qu'une imprimante et quand on utilise des tailles de police supérieures. Hormis les différences visuelles, l'accolement plus précis des deux écritures dessous et dessus la même base reflète la sémantique de l'expression.

Les attributs accent et accentunder ont les mêmes effets que les attributs de même nom des éléments mover (cf. la section 3.4.5 L'écriture dessus (mover)) et munder (cf. la section 3.4.4 L'écriture dessous (munder)) respectivement. Leurs valeurs par défaut se calculent de la même manière décrite pour ces éléments, la valeur par défaut de l'attribut accent dépendant de l'argument dessus et celle de l'attribut accentunder de l'argument dessous.

Si la base est un opérateur défini avec les attributs movablelimits="true" (ou un opérateur embelli dont l'élément mo nu est défini avecl l'attribut movablelimits="true") et displaystyle="false", alors les arguments dessous et dessus sont dessinés en position d'indice inférieur et en exposant, respectivement. Dans ce cas, les attributs accent et accentunder sont ignorés. On l'emploie souvent pour les limites sur des symboles tel que celui de somme &sum;.

Pour l'argument dessous, l'élément munderover règle toujours la valeur de l'attribut displaystyle à "false", mais il incrémente celle de l'attribut scriptlevel de 1 seulement quand la valeur de l'attribut accentunder est "false". Pour l'argument dessus, l'élément munderover règle toujours la valeur de l'attribut displaystyle à "false", mais il incrémente celle de l'attribut scriptlevel de 1 seulement quand la valeur de l'attribut accent est "false". Pour l'argument base, il laisse toujours les deux attributs inchangés. (Chaque élément hérite ces attributs au travers de son environnement de rendu, mais on ne peut les définir explicitement que sur l'élément mstyle [cf. la section 3.3.4 Les changements de style (mstyle)].)

3.4.6.3 Exemples

La représentation MathML de l'exemple montré précédemment est la suivante (la première expression utilise des éléments munder et mover distincts et la seconde un élément munderover) :

<mrow>
  <mover>
    <munder>
      <mo> &int; </mo>
      <mn> 0 </mn>
    </munder>
    <mi> &infin; </mi>
  </mover>
  <mtext> à comparer à </mtext>
  <munderover>
    <mo> &int; </mo>
    <mn> 0 </mn>
    <mi> &infin; </mi>
  </munderover>
</mrow>

3.4.7 Les préécritures et les indices tensoriels (mmultiscripts)

3.4.7.1 Description

La syntaxe de l'élément mmultiscripts est la suivante :

<mmultiscripts>
    base
     (indice exposant)*
     [ <mprescripts/> (préindice préexposant)* ]
</mmultiscripts>

Les notations des préécritures et des indices tensoriels sont représentées par un seul élément : l'élément mmultiscripts. Il permet la représentation d'un nombre quelconque de paires indice-exposant, alignées verticalement et accolées à une expression de base. Il gère à la fois les postécritures (à droite de la base en notation visuelle) et les préécritures (à gauche de la base en notation visuelle). Les écritures manquantes peuvent être représentées par l'élément vide none.

Les préécritures sont optionnelles et, si présentes, elles sont données après les postécritures, car les préécritures sont relativement rares par rapport à la notation tensorielle.

La séquence des arguments se compose de la base suivie par zéro à plusieurs paires indice-exposant, alignées verticalement (dans cet ordre), représentant toutes les postécritures. Cette liste est suivie en option par un élément vide mprescripts et une liste de zéro à plusieurs paires préindice-préexposant, représentant toutes les préécritures. Les listes de paires de postécritures et de préécritures se donnent dans un ordre de gauche-à-droite. Si aucun indice ou exposant ne devait être rendu à une position donnée, alors on devrait y utiliser l'élément vide none.

La base, les indices et les exposants, l'élément séparateur optionnel mprescripts, les préindices et les préexposants sont tous des sous-expressions de l'élément mmultiscripts, c.à.d. qu'elles sont toutes au même niveau dans l'arbre de l'expression. Qu'un argument soit un indice ou un exposant, ou soit un préindice ou un préexposant, on le détermine par sa position, paire ou impaire respectivement, en ignorant l'élément vide mprescripts dans cette détermination. Le premier argument, la base, est considéré être en position 1. Le nombre total des arguments doit être impair si l'élément mprescripts est absent ou pair sinon.

Les éléments vides mprescripts et none sont uniquement admis comme sous-expressions directes d'un élément mmultiscripts.

3.4.7.2 Attributs

Même chose que pour les attributs de l'élément msubsup.

L'élément mmultiscripts incrémente la valeur de l'attribut scriptlevel de 1 et règle celle de l'attribut displaystyle à "false", pour chacun de ses arguments sauf l'argument base pour lequel il laisse les deux attributs inchangés. (Chaque élément hérite ces attributs au travers de son environnement de rendu, mais on ne peut les définir explicitement que sur l'élément mstyle [cf. la section 3.3.4 Les changements de style (mstyle)].)

3.4.7.3 Exemples

Voici deux exemples d'utilisation de l'élément mmultiscripts :

0F1(;a;z)

<mrow>
  <mmultiscripts>
    <mi> F </mi>
    <mn> 1 </mn>
    <none/>
    <mprescripts/>
    <mn> 0 </mn>
    <none/>
  </mmultiscripts>
  <mo> &ApplyFunction; </mo>
  <mrow>
    <mo> ( </mo>
    <mrow> 
      <mo> ; </mo>
      <mi> a </mi>
      <mo> ; </mo>
      <mi> z </mi>
    </mrow> 
    <mo> ) </mo>
  </mrow>
</mrow>

R_i{}^j_{kl} (où k et l sont des indices différents)

<mmultiscripts>
  <mi> R </mi>
  <mi> i </mi>
  <none/>
  <none/>
  <mi> j </mi>
  <mi> k </mi>
  <none/>
  <mi> l </mi>
  <none/>
</mmultiscripts>

3.5 Les tables et les matrices

Les matrices, les groupements et autres notations mathématiques tabulaires se balisent avec des éléments mtable, mtr, mlabeledtr et mtd. Ces éléments sont similaires aux éléments TABLE, TR et TD de HTML, à la différence qu'ils offrent des attributs spécialisés pour contrôler la disposition fine nécessitée par les diagrammes commutatifs, les blocs de matrices, et ainsi de suite.

L'élément mlabeledtr représente une rangée de table étiquetée et peut servir pour des équations numériques. Le premier sous-élément de mlabeledtr est l'étiquette. Celle-ci est quelque peu particulière car elle n'est pas considérée comme une expression dans la matrice et elle n'est pas comptée dans la détermination du nombre de colonnes dans cette rangée.

3.5.1 Les tableaux ou matrices (mtable)

3.5.1.1 Description

On définit une matrice ou table à l'aide de l'élément mtable. Dans un élément mtable, seuls peuvent apparaître des éléments mtr ou mlabeledtr.

Dans MathML 1.x, l'élément mtable pouvait inférer des éléments mtr autour de ses arguments et l'élément mtr pouvait inférer des éléments mtd. En d'autres termes, si un certain argument d'un élément mtable n'était pas un élément mtr, l'application MathML devait supposer une rangée avec une seule colonne (c.à.d., l'argument était enveloppé de fait dans un élément mtr inféré). De même, si un certain argument d'un élément mtr (éventuellement inféré) n'était pas un élément mtd, cet argument devait être traité comme un élément de table, enveloppé dans un élément mtd inféré. MathML 2.0 déconseille d'inférer les éléments mtr et mtd ; on doit utiliser des éléments mtr et mtd dans les éléments mtable et mtr respectivement.

Les rangées de table ayant moins de colonnes que les autres rangées de cette même table (que les autres rangées la précèdent ou la suivent) sont effectivement comblées à droite par des éléments mtd vides afin que le nombre de colonnes dans chaque rangée soit ainsi égal au nombre maximum de colonnes dans n'importe quelle rangée de la table. Remarquez que l'utilisation d'éléments mtd, dont les attributs rowspan ou columnspan n'ont pas la valeur par défaut, peut affecter le nombre des éléments mtd à donner aux éléments mtr suivants pour couvrir un nombre donné de colonnes. Remarquez aussi que l'étiquette d'un élément mlabeledtr n'est pas considérée comme une colonne dans la table.

3.5.1.2 Attributs

Outre les attributs listés ci-dessous, cet élément admet les attributs id, xref, class et style, comme décrit dans la section 2.4.5 Les attributs communs à tous les éléments MathML.

Nom Valeurs Valeur par défaut
align (top | bottom | center | baseline | axis) [ numéro_de_rangée ] axis
rowalign (top | bottom | center | baseline | axis) + baseline
columnalign (left | center | right) + center
groupalign group-alignment-list-list {left}
alignmentscope (true | false) + true
columnwidth ( auto | number h-unit | namedspace | fit ) + auto
width auto | number h-unit auto
rowspacing ( number v-unit ) + 1.0ex
columnspacing ( number h-unit | namedspace ) + 0.8em
rowlines (none | solid | dashed) + none
columnlines (none | solid | dashed) + none
frame none | solid | dashed none
framespacing (number h-unit | namedspace) (number v-unit | namedspace) 0.4em 0.5ex
equalrows true | false false
equalcolumns true | false false
displaystyle true | false false
side left | right | leftoverlap | rightoverlap right
minlabelspacing number h-unit 0.8em

Remarquez que la valeur par défaut de chacun des attributs rowlines, columnlines et frame est la chaîne littérale "none", qui signifie le non-rendu par défaut des lignes et non l'absence de valeur par défaut.

Comme décrit dans la section 2.4.4 Les valeurs des attributs MathML, la notation (x | y)+ indique une ou plusieurs occurrences, soit de x, soit de y, séparées par des blancs. Par exemple, les valeurs possibles pour l'attribut columnalign sont left, left left et left right center center. S'il y a plus d'éléments que nécessaires (par exemple, plus d'éléments que de colonnes pour l'attribut columnalign), alors seuls les premiers éléments seront utilisés. S'il y a moins d'éléments, alors le dernier élément est répété autant que nécessaire. Par exemple, si columnalign>="right center" et que la table a trois colonnes, alors la première colonne sera alignée à droite et les deuxième et troisième seront centrées. L'étiquette d'un élément mlabeledtr n'est pas considérée comme étant une colonne dans la table, et les valeurs d'attribut qui s'appliquent aux colonnes ne s'appliquent pas aux étiquettes.

L'attribut align indique où aligner la table en fonction de son environnement. L'attribut axis indique un alignement du centre de la table sur l'axe d'environnement. (L'axe d'une équation est un alignement utilisé par les compositeurs. C'est la ligne sur laquelle le signe moins se tient en général. Le centre de la table est le point milieu du développement vertical de la table). Les attributs center et baseline indiquent tous deux d'aligner le centre de la table sur la ligne de base de l'environnement. Les attributs top ou bottom alignent le sommet ou le bas de la table sur la ligne de base de l'environnement.

Si la valeur de l'attribut align se termine par un numéro_de_rangée entre 1 et n (pour une table de n rangées), la rangée spécifiée s'aligne de la manière décrite précédemment, au lieu de la table dans son entier ; la rangée du haut (la première) a le numéro 1 et la rangée du bas (la dernière) le numéro n. C'est aussi vérifié si le numéro de rangée est négatif, entre -1 et -n, sauf que la rangée du bas aura le numéro -1 et celle du haut le numéro -n. D'autres valeurs de numéro_de_rangée sont illégales.

L'attribut rowalign indique comment devraient s'aligner les éléments dans chaque rangée. Par exemple, la valeur top signifie que les sommets de chaque élément de chaque rangée devraient être alignés avec ceux des autres éléments de cette rangée. L'attribut columnalign indique comment devraient s'aligner les éléments de chaque colonne.

Les attributs groupalign et alignmentscope sont décrits avec les éléments d'alignement maligngroup et malignmark dans la section 3.5.5 Les marqueurs d'alignement.

L'attribut columnwidth définit la largeur que devrait avoir une colonne. La valeur "auto" signifie que la colonne devrait être aussi large que nécessaire, c'est la valeur par défaut. Si on donne une valeur explicite, alors la colonne sera exactement de cette largeur et le contenu de cette colonne formaté pour loger dans cette largeur. Le contenu est soumis au formatage en lignes ou au rognage discrétionnaire du moteur de rendu. Si on donne la valeur "fit", le reste de la largeur de la page, après déduction des largeurs des colonnes définies avec une valeur "auto" et/ou avec des largeurs spécifiques, est divisé équitablement entre les colonnes ayant une valeur "fit", et cette valeur servira de largeur pour chacune d'elles. S'il ne reste pas assez de place pour loger le contenu des colonnes avec une valeur "fit", les moteurs de rendu peuvent formater ou rogner le contenu de ces colonnes avec une valeur fit. Quand l'attribut columnwidth est défini par un pourcentage, cette valeur est relative à la largeur de la table. C'est-à-dire qu'un moteur de rendu devrait essayer d'ajuster la largeur de la colonne de manière à ce qu'elle couvre le pourcentage indiqué de la largeur de la table entière.

L'attribut width définit la largeur voulue pour la table entière et il s'adresse aux agents utilisateurs visuels. Lorsque c'est un pourcentage, la valeur est relative à l'espace horizontal dont dispose le moteur de rendu MathML pour l'élément de table. Lorsque la valeur est "auto", le moteur de rendu MathML devrait calculer la largeur de la table d'après son contenu, quel que soit l'algorithme de disposition choisi.

MathML 2.0 ne définit pas d'algorithme de disposition de table. Notamment, le moteur de rendu MathML est chargé de résoudre les conflits survenant entre l'attribut width et les autres contraintes exercées sur la largeur de la table, telles que les valeurs explicites des attributs columnwidth et les dimensions minimales du contenu des cellules de la table. Pour une présentation des algorithmes de disposition de table, cf. la recommandation des feuilles de style en cascade, niveau 2 →vf.

Les attributs rowspacing et columnspacing définissent la quantité d'espace à ajouter entre chaque rangée et chaque colonne. Toutefois, l'espacement avant la première rangée et après la dernière (c.à.d., en haut et en bas de la table) est donné par le second nombre composant la valeur de l'attribut framespacing, et l'espacement avant la première colonne et après la dernière (c.à.d., à gauche et à droite de la table) par le premier nombre composant la valeur de l'attribut framespacing.

Dans les syntaxes de ces attributs, les valeurs h-unit ou v-unit représentent respectivement une unité de longueur horizontale ou verticale (cf. la section 2.4.4.2 Les attributs avec des unités). On emploie habituellement les unités indiquées pour les valeurs par défaut des attributs (em ou ex).

Les attributs rowlines et columnlines indiquent, s'il y a lieu, quels types de lignes ajouter entre chacune des rangées et colonnes. Les lignes avant la première rangée (ou colonne) et après la dernière rangée (ou colonne) sont données par l'attribut frame.

On utilise l'attribut frame si un cadre est souhaité autour de la table. Si la valeur de l'attribut n'est pas "none", alors on se sert de l'attribut framespacing pour ajouter un espacement entre les lignes du cadre et les premières et dernières rangées (ou colonnes) de la table. Si frame="none", alors l'attribut framespacing est ignoré. Les attributs frame et framespacing ne font pas partie des options rowlines/columnlines, rowspacing/columnspacing car, si c'était le cas, il faudrait souvent définir entièrement les attributs rowlines et columnlines au lieu de simplement leur donner une seule valeur. Par exemple, si une table a cinq colonnes et qu'on ne veuille aucun cadre autour de la table mais des lignes entre les colonnes, alors il faudrait définir columnlines="none solid solid solid solid none". Si le cadre est distinct des lignes internes, il n'est besoin que de columnlines="solid".

L'attribut equalrows forcent toutes les rangées à avoir la même hauteur totale pour la valeur "true". L'attribut equalcolumns forcent toutes les colonnes à avoir la même largeur pour la valeur "true".

L'attribut displaystyle définit la valeur de displaystyle (décrite dans l'élément mstyle à la section 3.3.4 Les changements de style (mstyle)) dans chaque cellule (élément mtd) de la table. Le réglage displaystyle="true" peut être utile sur les tables dont les éléments sont des expressions mathématiques entières ; la valeur par défaut "false" convient lorsque la table fait partie d'une expression, par exemple, quand elle représente une matrice. Dans l'un ou l'autre cas, l'attribut scriptlevel (section 3.3.4 Les changements de style (mstyle)) ne change pas pour les cellules de la table.

L'attribut side indique sur quel côté de la table l'étiquette devrait se placer. Cet attribut est prévue pour une utilisation avec les expressions étiquetées. Si les valeurs "left" ou "right" sont indiquées, l'étiquette se place respectivement au côté gauche ou droit de la rangée de table. Les deux autres valeurs d'attribut sont des variations sur les valeurs "left" et "right" : si la rangée étiquetée loge dans la largeur admise pour la table sans l'étiquette, mais ne loge pas dans cette largeur avec l'étiquette, alors l'étiquette recouvre la rangée et s'affiche au-dessus de celle-ci si la valeur de l'attribut rowalign de cette rangée est "top", sinon l'étiquette s'affiche en-dessous de la rangée.

S'il y a plusieurs étiquettes dans une table, leur alignement dans la colonne virtuelle qu'elles forment est sur la gauche, pour les étiquettes sur le côté gauche de la table, et sur la droite, pour celles sur le côté droit. On peut forcer l'alignement en définissant l'attribut columnalignment d'un élément mlabeledtr.

L'attribut minlabelspacing définit l'espace minimum autorisé entre une étiquette et l'élément adjacent dans la rangée.

3.5.1.3 Exemples

On peut représenter une matrice identité 3 par 3 comme suit :

<mrow>
  <mo> ( </mo>
  <mtable>
    <mtr>
      <mtd> <mn>1</mn> </mtd>
      <mtd> <mn>0</mn> </mtd>
      <mtd> <mn>0</mn> </mtd>
    </mtr>
    <mtr>
      <mtd> <mn>0</mn> </mtd>
      <mtd> <mn>1</mn> </mtd>
      <mtd> <mn>0</mn> </mtd>
    </mtr>
    <mtr>
      <mtd> <mn>0</mn> </mtd>
      <mtd> <mn>0</mn> </mtd>
      <mtd> <mn>1</mn> </mtd>
    </mtr>
  </mtable>
  <mo> ) </mo>
</mrow>

Ce qui pourrait se rendre par :

\left(\begin{array}{ccc}1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1\end{array}\right)

Remarquez que les parenthèses doivent être représentées explicitement, car elles ne font pas partie du rendu de l'élément mtable. Cela permet d'utiliser d'autres délimiteurs englobants, tels que des crochets, ou pas de délimiteur du tout.

3.5.2 Les rangées dans une table ou une matrice (mtr)

3.5.2.1 Description

L'élément mtr représente une rangé d'une table ou d'une matrice. L'élément mtr est seulement admis comme sous-expression directe d'un élément mtable et il institue que son contenu devrait former une rangée de la table. Chaque argument de l'élément mtr est placé dans une colonne différente de la table, en commençant à la colonne la plus à gauche.

Comme décrit dans la section 3.5.1 Les tables ou matrices (mtable), les éléments mtr sont effectivement comblés sur la droite par des éléments mtd quand ils sont plus courts que les autres rangées dans la table.

3.5.2.2 Attributs

Outre les attributs listés ci-dessous, cet élément admet les attributs id, xref, class et style, comme décrit dans la section 2.4.5 Les attributs communs à tous les éléments MathML.

Nom Valeurs Valeur par défaut
rowalign top | bottom | center | baseline | axis héritée
columnalign (left | center | right) + héritée
groupalign group-alignment-list-list héritée

Les attributs rowalign et columnalign permettent à une rangée particulière de forcer l'alignement indiqué par les mêmes attributs de l'élément mtable englobant.

Comme pour l'élément mtable, s'il y a plus d'éléments que nécessaires dans la valeur de l'attribut columnalign (c.à.d., plus d'éléments que de colonnes dans la rangée), alors les éléments supplémentaires seront ignorés. S'il y a moins d'éléments que de colonnes, alors le dernier élément sera répété autant de fois que nécessaire.

L'attribut groupalign est décrit avec les éléments d'alignement maligngroup et malignmark dans la section 3.5.5 Les marqueurs d'alignement.

3.5.3 Les lignes étiquetées des tableaux ou des matrices (mlabeledtr)

3.5.3.1 Description

L'élément mlabeledtr représente une rangée dans une table, cette rangée a une étiquette soit sur le côté gauche, soit sur le côté droit, comme déterminé par l'attribut side. L'étiquette est le premier sous-élément de mlabeledtr. Les sous-éléments restants forment le contenu de la rangée et sont identiques à ceux utilisés dans l'élément mtr ; tous les sous-éléments, hormis le premier, doivent être des éléments mtd.

L'élément mlabeledtr est seulement admis comme sous-expression directe d'un élément mtable. Chaque argument d'un élément mlabeledtr, sauf le premier (l'étiquette), se place dans une colonne différente de la table, en commençant par la colonne la plus à gauche.

Remarquez que l'élément étiquette n'est pas considéré comme étant une cellule dans la rangée de table. En particulier, l'élément étiquette n'est pas pris en compte dans la disposition de la table pour les calculs de largeur et d'alignement. Par exemple, dans le cas d'un élément mlabeledtr avec une étiquette et un seul sous-élément mtd centré, celui-ci est d'abord centré dans l'élément mtable englobant, l'étiquette est placée ensuite. Plus précisément, le sous-élément n'est pas centré dans l'espace restant dans la table après placement de l'étiquette.

Quoique MathML 2.0 ne définisse pas d'algorithme pour le placement des étiquettes, les développeurs de moteurs de rendu visuels trouveront peut-être utile le modèle de formatage suivant. Pour placer une étiquette, le développeur pourrait envisager les choses en termes de création d'une table plus grande ayant une colonne supplémentaire à chaque extrêmité. Les attributs columnwidth de ces deux colonnes de bordure auraient la valeur fit, de façon à s'étendre pour remplir l'espace éventuel restant après que les colonnes internes auront été disposées. Finalement, en fonction des valeurs des attributs side et minlabelspacing, l'étiquette est placée dans la colonne de bord appropriée, et éventuellement glissée vers le bas si nécessaire.

3.5.3.2 Attributs

Les attributs de l'élément mlabeledtr sont les mêmes que ceux de l'élément mtr. À la différence de ceux de l'élément mtable, les attributs de l'élément mlabeledtr applicables aux éléments des colonnes s'appliquent aussi à l'étiquette. Par exemple, dans une table avec une seule colonne :

<mlabeledtr rowalign='top'>

Cela signifie que l'étiquette et les autres éléments dans la rangée sont alignées verticalement à leurs sommets. Pour forcer un alignement particulier de l'étiquette, l'attribut adéquat devrait normalement se définir dans la balise ouvrante de l'élément mtd qui entoure le contenu de l'étiquette.

3.5.3.3 Le numérotage des équations

Le numérotage des équations est l'une des utilisations importantes de l'élément mlabeledtr. Dans un élément mlabeledtr, l'étiquette représentera le numéro de l'équation et les éléments dans la rangée les équations à numéroter. Les attributs side et minlabelspacing de l'élément mtable déterminent le placement du numéro de l'équation.

Dans les documents plus importants avec beaucoup d'équations numérotées, le numérotage automatique devient important. Bien que le numérotage automatique des équations et la résolution automatique de références en numéros d'équation n'entrent pas dans le cadre de MahtML, on peut répondre à ces problèmes en utilisant des feuilles de style ou d'autres moyens. La structure mlabeledtr permet une prise en charge de ces deux fonctions qui facilite un traitement XSLT. On peut utiliser l'élément mlabeledtr pour indiquer la présence d'une équation numérotée, donner au premier sous-élément le numéro d'équation courant, et en même temps incrémenter le numéro global de l'équation. Pour les références croisées, on pourrait utiliser un id, soit sur l'élément mlabeledtr, soit sur le premier élément même, comme cible d'un lien.

<mtable>
  <mlabeledtr id='e-egale-m-c-au-carre'>
    <mtd>
      <mtext> (2.1) </mtext>
    </mtd>
    <mtd>
     <mrow>
       <mi>E</mi>
       <mo>=</mo>
       <mrow>
        <mi>m</mi>
        <mo>&it;</mo>
        <msup>
         <mi>c</mi>
         <mn>2</mn>
        </msup>
       </mrow>
     </mrow>
    </mtd>
  </mlabeledtr>
</mtable>

Dont le rendu serait le suivant :

      E = mc2 (2.1)

3.5.4 Les éléments dans une table ou une matrice (mtd)

3.5.4.1 Description

Un élément mtd représente un élément (ou cellule) dans une table ou une matrice. L'élément mtd est seulement admis comme sous-expression directe d'un élément mtr ou d'un élément mlabeledtr.

L'élément mtd accepte un nombre quelconque d'arguments ; si ce nombre n'est pas 1, son contenu est traité comme un seul élément mrow inféré formé de tous ses arguments, comme décrit dans la section 3.1.3 Les arguments obligatoires.

3.5.4.2 Attributs

Nom Valeurs Valeur par défaut
rowspan number 1
columnspan number 1
rowalign top | bottom | center | baseline | axis héritée
columnalign left | center | right héritée
groupalign group-alignment-list héritée

Les attributs rowspan et columnspan permettent à un élément spécifique d'une matrice d'être traité comme s'il occupait le nombre de rangées ou de colonnes indiqué. La façon dont cet élément plus grand affecte la définition des rangées et des colonnes suivantes est prévue pour correspondre à l'interprétation des attributs similaires des tables HTML 4.01.

On peut utiliser les attributs rowspan et columnspan autour d'un élément mtd représentant l'étiquette d'un élément mlabeledtr. Également, l'étiquette d'un élément mlabeledtr n'est pas censée être influencé par les attributs rowspan ou columnspan précédents.

Les attributs rowalign et columnalign permettent à un élément de matrice particulier de forcer l'alignement indiqué par un élément mtable ou mtr environnants.

L'attribut groupalign est décrit avec les éléments d'alignement maligngroup et malignmark dans la section 3.5.5 Les marqueurs d'alignement.

3.5.5 Les marqueurs d'alignement

3.5.5.1 Description

Les marqueurs d'alignement sont des éléments pareils à des espaces (cf. la section 3.2.7 L'espacement (mspace)) qu'on peut employer pour aligner verticalement des points définis dans une colonne d'expressions MathML par insertion automatique de la quantité d'espace horizontal nécessaire entre des sous-expressions définies.

La discussion suivante s'appuiera sur l'exemple d'un jeu d'équations simultanées, à rendre avec un alignement vertical des coefficients et des variables de chaque terme en insérant des espacements, un peu comme illustré ici :

    8.44x + 55  y =  0
    3.1 x -  0.7y = -1.1

Si les expressions de l'exemple précédent étaient arrangées en colonnes, mais non alignées, elles apparaîtrait comme cela :

    8.44x + 55y = 0
    3.1x - 0.7y = -1.1

(Pour les moteurs de rendu audio, on suggère que les éléments d'alignement produisent un comportement analogue par une altération du rythme de la prononciation afin qu'il soit le même pour plusieurs sous-expressions dans la colonne, en insérant un délai adéquat remplaçant l'espacement horizontal supplémentaire décrit ici).

Les expressions dont il faut aligner les parties (chaque équation de l'exemple précédent) doivent être annoncées comme éléments de table (c.à.d., comme éléments mtd) d'une colonne d'un élément mtable. Pour éviter les confusions, nous emploierons le terme cellule de table au lieu d'élément de table dans la suite de cette section.

Toutes les interactions entre les éléments d'alignement se limitent à la colonne de l'élément mtable où ils apparaissent. C'est-à-dire que chaque colonne d'une table définie par un élément mtable se comporte comme un champ d'alignement confinant tous les effets d'alignement provenant de son contenu. Cela exclut également toute interaction entre ses propres éléments d'alignement et ceux à l'intérieur des éventuels champs d'alignement imbriqués qu'elle contiendrait.

La raison pour laquelle les colonnes d'un élément mtable servent de champs d'alignement, c'est qu'elles constituent le seul moyen général dans MathML d'arranger les expressions en colonnes verticales. D'autres versions de MathML apporteront peut-être un élément malignscope qui permettra la création d'un champs d'alignement autour de n'importe quel élément MathML. Cependant, même alors, les colonnes de table devront encore parfois agir comme des champs d'alignement et, puisque ce ne sont pas des éléments mais plutôt des parties correspondantes provenant de plusieurs éléments mtr, elles ne pourront pas constituer individuellement le contenu d'un élément du champs d'alignement.

On peut donner à l'élément mtable un attribut alignmentscope="false" pour que ses colonnes ne se comportent pas comme des champs d'alignement. Les détails se trouvent à la fin de cette section. La discussion dans cette section suppose sinon que cet attribut a sa valeur par défaut "true".

3.5.5.2 La définition des groupes d'alignement

Pour effectuer l'alignement, dans chacune des expressions à aligner, il faut définir les points devant s'aligner sur les points correspondants des autres expressions et le début de chaque groupe d'alignement de sous-expressions, que l'on peut faire glisser horizontalement en bloc pour réaliser l'alignement. Chaque groupe d'alignement doit contenir un point d'alignement. Il faut également indiquer quelles expressions dans la colonne n'ont pas du tout de groupe d'alignement mais sont seulement affectées par l'alignement de colonne ordinaire de cette colonne de la table, c.à.d. par l'attribut columnalign décrit ailleurs.

Les groupes d'alignement commencent aux emplacements des éléments maligngroup invisibles, rendus par une largeur nulle, quand ils apparaissent hors d'un champ d'alignement, et par un espace horizontal juste suffisant pour provoquer l'alignement voulu du groupe d'alignement qui les suit, à l'intérieur d'un champ d'alignement. On donne plus loin un algorithme simple permettant à une application MathML d'y parvenir. Dans l'exemple précédent, chaque équation aurait un élément maligngroup avant chaque coefficient, variable et opérateur dans l'égalité de gauche, un autre avant le signe égal à = et encore un avant la constante dans l'égalité de droite.

En général, une cellule de table contenant n éléments maligngroup contient n groupes d'alignement, le ième groupe composé entièrement des éléments situés après le ième élément maligngroup et avant le (i+1)ème ; aucun élément du contenu de la cellule de table ne devrait entièrement apparaître avant son premier élément maligngroup.

Remarquez que la division entre groupes d'alignement ne correspond pas forcément à la structure imbriquée de l'expression MathML contenant les groupes, c'est-à-dire qu'un groupe d'alignement peut, par exemple, se composer de la fin d'un élément mrow, entièrement d'un deuxième et du début d'un troisième. On peut le constater dans le balisage MathML du présent exemple donné à la fin de cette section.

La structure des expressions imbriquées formée par les éléments mrow et les autres schémas de disposition devrait refléter la structure mathématique de l'expression, pas la structure des groupes d'alignement, afin d'obtenir des rendus optimaux et de meilleures interprétations automatiques (cf. la discussion sur le bon regroupement dans la section 3.3.1 Le regroupement horizontal des sous-expressions (mrow)). L'insertion d'éléments d'alignement (ou d'autres éléments pareils à des espaces) ne devrait pas altérer la correspondance entre la structure d'une expression MathML et la structure de l'expression mathématique qu'elle représente.

Bien que les groupes d'alignement doivent nécessairement coïncider avec la structure des expressions imbriquées des schémas de disposition, il existe néanmoins des restrictions sur les emplacements permis aux éléments maligngroup dans une cellule de table. Seuls les éléments des types suivants (eux-mêmes dans la cellule de table) peuvent contenir un élément maligngroup :

Ces restrictions visent à assurer des définitions d'alignement sans ambiguïté, tout en évitant des complications comme des écritures dessus, des signes de radicaux et des barres de fraction. Elles servent aussi à garantir un algorithme simple suffisant pour obtenir l'alignement voulu.

Remarquez que certaines positions de l'élément maligngroup, même si elles sont légales, n'ont aucune utilité, comme pour un élément maligngroup d'être l'argument d'un élément mfenced. À l'insertion d'un élément maligngroup avant un élément donné dans un code MathML préexistant, il sera souvent nécessaire, et toujours acceptable, de former un nouvel élément mrow pour juste les contenir. En général, cela sera nécessaire, sauf quand l'élément maligngroup s'insère directement dans un élément mrow, ou dans un élément qui peut former un mrow inféré à partir de son contenu. Cf. l'avertissement à propos du regroupement légal des éléments pareils à des espaces dans la section 3.2.7 L'espacement (mspace).

Pour les cellules de table divisées en groupes d'alignement, chaque élément de leur contenu doit appartenir exactement à un seul groupe d'alignement, sauf les éléments de la liste précédente qui contiennent les éléments maligngroup ainsi que les éléments maligngroup mêmes. Au sein d'une cellule de table contenant des groupes d'alignement, le premier élément entier doit donc être un élément maligngroup, quoique les balises ouvrantes d'autres éléments puissent le précéder.

Cette condition supprime une confusion potentielle concernant l'alignement des éléments avant le premier élément maligngroup et facilite l'identification des cellules de table laissées entièrement hors du processus d'alignement de leur colonne.

Remarquez que les cellules de table qui sont divisées en groupes d'alignement, dans une colonne, ne contiennent pas obligatoirement chacune le même nombre de groupes. Si ce nombre diffère, des groupes d'alignement à chasse nulle sont effectivement ajoutés à la droite de chaque cellule de table dont le nombre de groupes est moindre de celui des autres cellules de table de la même colonne.

3.5.5.3 Les cellules de table non divisées en groupes d'alignement

Les expressions dans une colonne prévues pour ne pas avoir de groupes d'alignement ne devraient pas contenir d'éléments maligngroup. Les expressions sans groupe d'alignement sont seulement alignées en utilisant l'attribut columnalign, qui s'applique sur la colonne de table dans son entier, et elles ne sont pas affectées par l'attribut groupalign décrit ci-dessous. Si une telle expression est plus large que la largeur de colonne nécessaire pour les cellules de table contenant des groupes d'alignement, toutes les cellules de table avec des groupes d'alignement glisseront en bloc dans la colonne, selon l'attribut columnalign de cette colonne. Par exemple, on pourrait ajouter une rubrique de colonne sans alignement interne à la colonne des deux équations donnée précédemment, en les faisant précéder d'une autre rangée de table contenant un élément mtext pour la rubrique et en utilisant la valeur par défaut columnalign="center" de la table pour obtenir :

équations avec variables alignées
      8.44x + 55  y =  0
      3.1 x -  0.7y = -1.1

Ou avec une rubrique plus courte :

 quelques équations
8.44x + 55  y =  0
3.1 x -  0.7y = -1.1

3.5.5.4 La définition des points d'alignement avec l'élément malignmark

On peut définir le point d'alignement de chaque groupe d'alignement par un élément malignmark n'importe où dans le groupe d'alignement (sauf dans un autre champ d'alignement contenu entièrement dans ce groupe d'alignement) ou bien il se détermine automatiquement à partir de l'attribut groupalign. L'attribut groupalign peut se définir sur l'élément maligngroup précédent dans le groupe ou sur les éléments englobants mtd, mtr ou mtable. Dans les cas habituels, l'attribut groupalign suffit à décrire les points d'alignement voulus, et l'utilisation d'éléments malignmark ne sera donc pas nécessaire.

L'élément malignmark indique que le point d'alignement devrait se placer sur le bord droit de l'élément précédent ou sur le bord gauche de l'élément (ou du caractère) suivant, selon la valeur de l'attribut edge de l'élément malignmark. Remarquez qu'il faudra peut-être faire appel à un élément mrow pour regrouper un élément malignmark et un élément voisin, afin de ne pas altérer le compte des arguments de l'élément conteneur. (Cf. l'avertissement au sujet du regroupement légal des éléments pareils à des espaces dans la section 3.2.7 L'espacement (mspace)).)

Lorsqu'un élément malignmark apparaît dans un groupe d'alignement, il peut advenir dans un élément à une profondeur d'imbrication arbitraire dans le groupe, tant que ce n'est pas dans un champ d'alignement imbriqué. Il n'est pas soumis aux mêmes restrictions de position que les éléments maligngroup. Par contre, son entourage immédiat doit être tel que l'élément à sa droite, ou à sa gauche (selon la valeur de son attribut edge), puisse être identifié sans ambiguïté. Si aucun élément de ce type ne correspond, les moteurs de rendu devraient se comporter comme si un élément à chasse nulle y avait été inséré.

Pour les besoins de l'alignement, un élément X est censé se trouver immédiatement à gauche d'un élément Y, et Y immédiatement à droite de X, dès lors que X et Y sont des arguments successifs d'un élément mrow (éventuellement inféré), pour X venant avant Y. Dans le cas des éléments mfenced, les applications MathML devraient évaluer cette relation comme si l'élément mfenced avait été remplacé par la forme développée équivalente faisant intervenir un élément mrow. De même, un élément maction devrait être traité comme s'il avait été remplacé par sa sous-expression sélectionnée courante. Pour tous les autres cas, aucune relation immédiatement à gauche ou à droite entre deux éléments X et Y n'est définie. Toutefois, en cas d'éléments de contenu éparpillés dans un balisage de présentation, les applications MathML devraient essayer d'évaluer logiquement cette relation. Par exemple, si un moteur de rendu conserve une structure de présentation interne du rendu des éléments de contenu, l'évaluation de cette relation pourrait se faire par rapport à cette structure. (Cf. le chapitre 4 Le balisage de contenu et le chapitre 5 La combinaison des balisages de contenu et de présentation pour des précisions à propos du mélange des balisages de présentation et de contenu).

À la différence des autres éléments MathML, les éléments malignmark peuvent apparaître dans le contenu d'éléments atomiques, tels que mn, mi ou mtext. Auquel cas, le caractère immédiatement avant (ou après) l'élément malignmark portera le point d'alignement et, dans tous les autres cas, ce sera l'élément immédiatement à sa gauche (ou à sa droite). La justification de cette règle tient au fait que l'alignement est parfois souhaitable sur les bords de caractères spécifiques au sein des éléments atomiques formés de plusieurs caractères.

S'il y a plusieurs malignmark dans un groupe d'alignement, tous seront ignorés hormis le premier. Les applications MathML peuvent proposer un mode pour avertir de cette situation, qui n'est pas une condition erreur, et elles ne devraient pas lancer d'avertissement par défaut. (Justification : Il ne serait pas commode d'avoir à retirer tous les éléments malignmark superflus dans des données générées automatiquement, dans certains cas, comme lorsqu'ils servent à indiquer un alignement sur d'autres points décimaux que le caractère point .).

3.5.5.5 Attributs

Outre les attributs listés ci-dessous, l'élément malignmark admet les attributs id, xref, class et style, comme décrit dans la section 2.4.5 Les attributs communs à tous les éléments MathML.

Nom Valeurs Valeur par défaut
edge left | right left

L'attribut edge de l'élément malignmark indique si le point d'alignement se trouvera sur le bord gauche ou sur le bord droit d'un certain élément ou caractère. L'emplacement précis désigné par bord gauche ou bord droit est expliqué ci-dessous. Si edge="right", le point d'alignement est le bord droit de l'élément (ou du caractère) immédiatement à gauche de l'élément malignmark. Si edge="left", le point d'alignement est le bord gauche de l'élément (ou du caractère) immédiatement à droite de l'élément malignmark. Remarquez que l'attribut se rapporte au choix du bord plutôt qu'à la direction où chercher l'élément dont le bord sera utilisé.

Pour les éléments malignmark qui adviennent dans le contenu d'éléments atomiques MathML, on utilise le caractère précédent (ou suivant) dans le contenu de l'élément atomique ; si aucun caractère ne correspond, un caractère de chasse nulle est effectivement inséré afin qu'il porte le point d'alignement sur son bord. Pour ceux dans tous les autres cas, on utilise l'élément précédent (ou suivant) ; si aucun élément ne correspond, un élément de chasse nulle est effectivement inséré afin qu'il porte le point d'alignement.

MathM ne donne aucune définition précise du bord gauche ou du bord droit d'un caractère ou d'un glyphe (par exemple, s'il doit coïncider avec un bord de la boîte englobante du caractère), cela est laissé à la discrétion du moteur de rendu ; celui-ci peut faire dépendre la position du bord du caratère ou bien de son contexte.

Pour bien aligner des colonnes de nombres (en utilisant les valeurs "left", "right" ou "decimalpoint" de l'attribut groupalign), il faudra vraisemblablement que la largeur effective (c.à.d., la distance entre les bords gauche et droit) des chiffres décimaux reste constante, même si les largeurs de leurs boîtes englobantes ne le sont pas (par exemple, si le chiffre 1 est plus étroit que les autres chiffres). Pour les autres caractères, tels que les lettres et les opérateurs, il sera peut-être souhaitable que les bords alignés coïncident avec la boîte englobante.

Le bord gauche d'un élément (ou d'un groupe d'alignement) MathML se rapporte au bord gauche du glyphe le plus à gauche dessiné pour rendre l'élément (ou le groupe), sauf qu'on devrait aussi compter l'espace explicite représenté par des éléments mspace ou mtext comme des glyphes dans ce contexte, tout comme les glyphes qui auraient été dessinés sinon pour des éléments mphantom autour d'eux. Et inversement pour le bord droit d'un élément ou d'un groupe d'alignement.

3.5.5.6 Attributs

Outre les attributs listés ci-dessous, l'élément maligngroup admet les attributs id, xref, class et style, comme décrit dans la section 2.4.5 Les attributs communs à tous les éléments MathML.

Nom Valeurs Valeur par défaut
groupalign left | center | right | decimalpoint héritée

L'attribut groupalign de l'élément maligngroup sert à déterminer la position du point d'alignement de son groupe quand aucun élément malignmark n'est présent. L'explication suivante suppose l'absence d'élément malignmark dans le groupe.

Dans l'exemple au début de cette section, on a une colonne de 2 cellules de table, avec 7 groupes d'alignement dans chaque cellule de table ; on a donc 7 colonnes de groupes d'alignement, avec 2 groupes, l'un au-dessus de l'autre, dans chaque colonne. Ces colonnes de groupes d'alignement devraient recevoir les 7 valeurs d'attribut groupalign "decimalpoint left left decimalpoint left left decimalpoint", dans cet ordre. On décrit plus loin comment définir cette liste de valeurs pour une cellule de table (ou une colonne de table) dans son entier, en utilisant des attributs sur les éléments entourant l'élément maligngroup.

Si la valeur de l'attribut groupalign est "left", "right" ou "center", on définit le point d'alignement pour se trouver, respectivement, sur le bord gauche du groupe, sur son bord droit ou à mi-chemin entre ces bords. Les significations des termes bord gauche et bord droit sont les mêmes que celles expliquées pour l'élément malignmark.

Si la valeur de l'attribut groupalign est "decimalpoint", le point d'alignement est le bord droit du dernier caractère avant le point décimal. Le point décimal est le premier caractère point . (ASCII 0x2e) dans le premier élément mn trouvé au long de la ligne de base du groupe d'alignement. Plus précisément, on parcourt récursivement le groupe d'alignement, en profondeur d'abord, jusqu'au premier élément mn, en explorant tous les arguments de chaque élément de type mrow (y compris les éléments mrow inférés), mstyle, mpadded, mphantom, mfenced ou msqrt, en explorant seulement le premier argument de chaque élément d'écriture (msub, msup, msubsup, munder, mover, munderover, mmultiscripts) ou de chaque élément mroot ou semantics, en explorant seulement la sous-expression sélectionnée de chaque élément maction et en sautant le contenu de tous les autres éléments. Le premier élément mn trouvé ainsi contient toujours le point d'alignement, qui est le bord droit du dernier caractère avant le premier point décimal dans le contenu de l'élément mn. S'il n'y a aucun point décimal dans l'élément mn, le point d'alignement est le bord droit du dernier caractère dans le contenu. Si le point décimal est le premier caractère du contenu de l'élément mn, on utilise le bord droit d'un caractère de chasse nulle inséré avant le point décimal. Si aucun élément mn n'est trouvé, on se sert du bord droit du groupe d'alignement entier (comme pour groupalign="right").

Pour permettre un alignement sur les points décimaux dans les éléments cn, une application MathML peut convertir une expression de contenu en une expression de présentation dont le rendu est identique avant de rechercher les points décimaux comme décrit précédemment.

Si d'autres caractères que le point . devait servir de points décimaux pour l'alignement, on devrait les faire précéder par des éléments malignmark au sein même du contenu de l'atome mn.

Pour toutes les valeurs de l'attribut groupalign, si un élément malignmark explicite est présent à une position quelconque dans le groupe, la position qu'il indique (décrite précédemment) remplace le point d'alignement déterminé automatiquement à partir de la valeur de l'attribut groupalign.

3.5.5.7 L'héritage des valeurs de l'attribut groupalign

Il n'est généralement pas nécessaire de placer un attribut groupalign sur chaque élément maligngroup. Dans la mesure où cet attribut est habituellement le même pour chaque groupe d'une colonne de groupes d'alignement à aligner, sa valeur pourra être héritée d'un attribut sur l'élément mtable utilisé pour établir le champ d'alignement dans son entier, ou des éléments mtr ou mtd entourant le groupe d'alignement. Elle s'hérite au travers d'une voie d'héritage qui chemine successivement depuis l'élément mtable à travers les éléments contenus mtr, mtd et maligngroup. Il existe exactement un seul élément de chacun de ces types sur cette voie, depuis l'élément mtable jusqu'à tous les groupes d'alignement qui y sont contenus. En général, un groupe d'alignement donné hérite de la valeur de l'attribut groupalign au travers de l'élément le plus proche entourant le groupe d'alignement et fournissant une définition explicite de cet attribut.

Toutefois, remarquez que chaque élément mtd nécessite généralement une liste de valeurs groupalign, une pour chaque élément maligngroup qui s'y trouve plutôt que d'une seule valeur. En outre, un élément mtr (ou mtable) nécessite généralement une liste de listes de valeurs groupalign, puisque cet élément s'étend sur plusieurs colonnes de l'élément mtable, chacune agissant éventuellement comme un champ d'alignement. On définit ces listes de valeurs de groupe d'alignement en utilisant les règles de syntaxe suivantes :

group-alignment            := left | right | center | decimalpoint
group-alignment-list       := group-alignment +
group-alignment-list-list := ( '{' group-alignment-list '}' ) +

Comme décrit dans la section 2.4.4 Les valeurs des attributs MathML, le caractère barre verticale | sépare des options, le caractère signe plus + indique une répétition optionnelle (c.à.d., une ou plusieurs copies de ce qui précède), les valeurs supplémentaires sont ignorées et la dernière répétée si besoin pour couvrir les colonnes de table ou les colonnes de groupe d'alignement supplémentaires ; les caractères accolade ouvrante { et accolade fermante } représentent des accolades littérales et les caractères parenthèse ouvrante ( et parenthèse fermante ) servent à regrouper, sans apparition littérale dans la valeur de l'attribut.

Les valeurs admissibles de l'attribut groupalign pour les éléments qui l'acceptent sont définies en utilisant la syntaxe précédente comme suit :

Type de l'élément Syntaxe de l'attribut groupalign Valeur par défaut
mtable group-alignment-list-list {left}
mtr group-alignment-list-list héritée de l'attribut sur l'élément mtable
mtd group-alignment-list héritée de l'attribut sur l'élément mtr
maligngroup group-alignment héritée de l'attribut sur l'élément mtd

Dans l'exemple au début de cette section, on aurait pu définir les valeurs de groupe d'alignement sur chaque élément mtd avec groupalign="decimalpoint left left decimalpoint left left decimalpoint", ou sur chaque élément mtr avec groupalign="{decimalpoint left left decimalpoint left left decimalpoint}", ou (plus commodément) sur l'élément mtable comme un tout avec groupalign="{decimalpoint left left decimalpoint left left decimalpoint}", formant une seule liste de valeurs de groupe d'alignement entre accolades pour la seule colonne d'expressions à aligner.

3.5.5.8 Une représentation MathML d'un exemple d'alignement

Les règles précédentes suffisent à expliquer la représentation MathML de l'exemple donné au début de cette section. Répétant l'exemple, le rendu souhaité est le suivant :

    8.44x + 55  y =  0
    3.1 x -  0.7y = -1.1

Une représentation dans MathML serait :

<mtable groupalign="decimalpoint left left decimalpoint left left decimalpoint">
  <mtr>
    <mtd>
      <mrow>
        <mrow>
          <mrow>
            <maligngroup/>
            <mn> 8.44 </mn>
            <mo> &InvisibleTimes; </mo>
            <maligngroup/>
            <mi> x </mi>
          </mrow>
          <maligngroup/>
          <mo> + </mo>
          <mrow>
            <maligngroup/>
            <mn> 55 </mn>
            <mo> &InvisibleTimes; </mo>
            <maligngroup/>
            <mi> y </mi>
          </mrow>
        </mrow>
      <maligngroup/>
      <mo> = </mo>
      <maligngroup/>
      <mn> 0 </mn>
    </mrow>
    </mtd>
    <mtd>
      <mrow>
        <mrow>
          <mrow>
            <maligngroup/>
            <mn> 3.1 </mn>
            <mo> &InvisibleTimes; </mo>
            <maligngroup/>
            <mi> x </mi>
          </mrow>
          <maligngroup/>
          <mo> - </mo>
          <mrow>
            <maligngroup/>
            <mn> 0.7 </mn>
            <mo> &InvisibleTimes; </mo>
            <maligngroup/>
            <mi> y </mi>
          </mrow>
        </mrow>
        <maligngroup/>
        <mo> = </mo>
        <maligngroup/>
        <mrow>
          <mo> - </mo>
          <mn> 1.1 </mn>
        </mrow>
      </mrow>
    </mtd>
  </mtr>
</mtable>

3.5.5.9 Autres précisions concernant les éléments d'alignement

Les éléments d'alignement maligngroup et malignmark peuvent apparaître hors des champs d'alignement, où ils seront ignorés. La justification de ce comportement tient au fait que, dans les situations où le code MathML est généré, ou copié d'un autre document, sans savoir s'il sera placé dans un champ d'alignement ou non, il serait compliqué d'y reconnaître une condition d'erreur.

On peut définir sur l'élément mtable l'attribut alignmentscope="false" pour faire en sorte que ses colonnes n'agissent pas comme des champs d'alignement. En général, la syntaxe de cet attribut est (true|false)+ ; si sa valeur est une liste de valeurs booléennes, chacune d'elles s'applique à une colonne, la dernière valeur se répétant si besoin pour couvrir des colonnes supplémentaires et les valeurs en trop étant ignorées. Les colonnes qui ne sont pas des champs d'alignement font partie, le cas échéant, du champs d'alignement entourant l'élément mtable. L'emploi de alignmentscope="false" permet aux tables imbriquées de contenir des éléments malignmark pour aligner la table intérieure dans le champ d'alignement englobant.

Comme expliqué précédemment, le traitement de l'alignement des éléments de contenu n'est pas bien défini, car MathML ne spécifie pas comment rendre les éléments de contenu. Toutefois, beaucoup d'applications MathML trouveront vraisemblablement pratique de convertir en interne les éléments de contenu en éléments de présentation rendus de la même façon. Ainsi, en règle générale, même si le moteur de rendu ne réalise pas cette conversion en interne, on recommande que les éléments d'alignement soit traités comme si une telle conversion avait lieu.

Un cas particulièrement important, à gérer par les moteurs de rendu avec élégance, est l'interaction des éléments d'alignement avec l'élément de contenu matrix car, pour le rendu, cet élément peut être converti en interne ou pas en une expression contenant un élément mtable. Pour résoudre partiellement cette ambiguïté, si l'élément matrix est converti en une expression impliquant un élément mtable, on suggère, sans obligation, que l'élément mtable reçoive l'attribut alignmentscope="false", ce qui ne rendra pas différente l'interaction de l'élément matrix et des éléments d'alignement de celle d'un élément de présentation générique (notamment, cela lui permettra de contenir des éléments malignmark agissant dans les champs d'alignement créés par les colonnes d'un élément mtable contenant l'élément matrix dans l'une de ses cellules de table).

L'effet des éléments d'alignement dans les cellules de table dont les attributs columnspan ou rowspan n'ont pas de valeur par défaut n'est pas défini, sinon qu'un tel usage des éléments d'alignement ne constitue pas une condition erreur. D'autres versions de MathML pourront définir le comportement des éléments d'alignement dans de telles cellules de table.

L'effet du possible saut de ligne d'un élément mtable sur les éléments d'alignement n'est pas défini.

3.5.5.10 Un algorithme d'alignement simple

Voici un algorithme simple d'après lequel une application MathML peut effectuer l'alignement défini dans cette section. Puisque la définition d'alignement est déterministe (sauf la définition des bords gauche et droit d'un caractère), tout algorithme d'alignement MathML correct suivra le même comportement que celui-ci. On peut traiter chaque colonne d'un élément mtable (champ d'alignement) indépendamment ; cet algorithme s'applique à une colonne de mtable et prend en compte les éléments d'alignement, l'attribut groupalign décrit dans cette section et l'attribut columnalign décrit avec l'élément mtable (section 3.5.1 Les tables ou matrices (mtable)).

Premièrement, on calcule un rendu pour le contenu de chaque cellule de table dans la colonne, en utilisant des largeurs nulles pour tous les éléments maligngroup et malignmark. Le rendu final sera identique, hormis les glissements horizontaux appliqués à chaque groupe d'alignement et/ou cellule de table. Les positions des points d'alignement définis par les éventuels éléments malignmark sont notées et les points d'alignement restants sont déterminés en utilisant les valeurs de l'attribut groupalign.

Pour chaque groupe d'alignement, les positions horizontales du bord gauche, du point d'alignement et du bord droit sont notées, ce qui permet la détermination de la largeur du groupe de chaque côté des points d'alignement (gauche et droite). La somme de ces deux largeurs latérales, c.à.d., la somme des largeurs à gauche et à droite du point d'alignement, sera égale à la largeur du groupe d'alignement.

Deuxièmement, chaque colonne de groupes d'alignement est balayée de gauche à droite. Le ième balayage couvre le ième groupe d'alignement dans chaque cellule de table contenant des groupes d'alignement. Les cellules de table sans groupe d'alignement, ou avec moins de i groupes d'alignement sont ignorées. Chaque balayage est l'occasion de calculer deux maximums sur les groupes d'alignement explorés : la largeur maximale à gauche du point d'alignement et la largeur maximale à droite du point d'alignement de chaque groupe d'alignement exploré.

La somme de toutes les largeurs maximales calculées (deux par colonne de groupes d'alignement) donne une largeur totale qui sera celle de chaque cellule de table contenant des groupes d'alignement. Soit n le nombre maximum de groupes d'alignement dans une cellule : la largeur de chacune de ces cellules est divisée en 2n sections adjacentes, appelées G(i) et D(i) pour i valant 1 à n, en utilisant les 2n largeurs latérales maximales calculées précédemment ; pour chaque i, la largeur de toutes les sections G(i) est la largeur maximale de chaque ième groupe d'alignement de la cellule à gauche de son point d'alignement, et la largeur de toutes les sections D(i) est la largeur maximale de chaque ième groupe d'alignement de la cellule à droite de son point d'alignement.

Les groupes d'alignement se positionnent ensuite de façon unique en plaçant la partie de chaque ième groupe à gauche de son point d'alignement dans la section G(i) et la partie de chaque ième groupe à droite de son point d'alignement dans la section appelée D(i). Le point d'alignement de chaque ième groupe se trouve finalement à la frontière entre les sections adjacentes G(i) et D(i), de sorte que tous les points d'alignement des ième groupes ont la même position horizontale.

Les largeurs des cellules de table ne contenant pas de groupes d'alignement ont été calculées dans le cadre du rendu initial et elles peuvent différer pour chaque cellule et différer de la largeur unique utilisée pour les cellules contenant des groupes d'alignement. Le maximum de toutes les largeurs de cellule (des deux types) donne la largeur de la colonne de table dans son entier.

La position de chaque cellule dans la colonne est déterminée par la partie concernée de la valeur de l'attribut columnalign de l'élément englobant mtable, mtr ou mtd le plus proche avec une valeur explicite, comme décrit dans les sections traitant de ces éléments. Cela signifie que les cellules contenant des groupes d'alignement glisseront peut-être dans leur colonne, en plus du glissement opéré par leurs groupes d'alignement à l'intérieur des cellules, comme décrit précédemment, mais dans la mesure où les cellules de ce type ont la même dimension, elles glisseront de la même quantité dans la colonne, en conservant ainsi l'alignement vertical des points d'alignement des groupes d'alignement correspondants dans chaque cellule.

3.6 L'animation des expressions

3.6.1 L'adjonction d'une action à une sous-expression (maction)

Dans beaucoup de situations, il peut être souhaitable de rendre le contenu mathématique actif. Ajouter un lien à une sous-expression MathML constitue un type d'interactivité de base. Cf. la section 7.1.4 Le mélange et la liaison de MathML et HTML. Toutefois, les mécanismes de liaison génériques ne permettent pas d'obtenir nombre d'autres types d'interactivité. Par exemple, pour les expressions mathématiques longues, on peut offrir la faculté de les plier, c.à.d. que le moteur de rendu pourrait permettre au lecteur de basculer entre une ellipse et l'expression bien plus longue qu'elle représente.

MathML fournit l'élément maction comme mécanisme pour associer des actions à des expressions. Cet élément accepte un nombre quelconque de sous-expressions comme arguments.

3.6.1.1 Attributs

Outre les attributs listés ci-dessous, cet élément admet les attributs id, xref, class et style, comme décrit dans la section 2.4.5 Les attributs communs à tous les éléments MathML.

Nom Valeurs Valeur par défaut
actiontype (décrites ci-dessous) (attribut obligatoire, pas de valeur par défaut)
selection positive-integer 1

Par défaut, les applications MathML ne reconnaissant pas l'attribut défini actiontype devraient rendre la sous-expression sélectionnée comme indiqué plus loin. S'il n'y a pas de sous-expression sélectionnée, c'est une condition d'erreur MathML ; le rendu qui convient dans ce cas est celui décrit dans la section 7.2.2 La gestion des erreurs.

Puisqu'une application conforme à MathML n'est pas tenue de reconnaître toutes les valeurs particulières de l'attribut actiontype, elle peut l'être entièrement juste en mettant en œuvre le comportement par défaut décrit précédemment.

L'attribut selection est fourni pour les valeurs de l'attribut actiontype qui permettent à un lecteur du document de sélectionner pour visualisation l'une parmi plusieurs sous-expressions. Sa valeur devrait être l'entier positif qui désigne l'une des sous-expressions de l'élément maction, numérotées de 1 jusqu'au nombre de ses sous-éléments. Le cas échéant, on définit la sous-expression ainsi désignée comme étant la sous-expression sélectionnée de l'élément maction, sinon il n'existe pas de sous-expression sélectionnée, ce qui constitue une condition d'erreur. Lorsque l'attribut selection n'est pas défini (y compris les types d'action pour lesquels il n'a aucun sens), sa valeur par défaut est 1, et la sous-expression sélectionnée sera donc la première sous-expression.

En outre, comme décrit dans le chapitre 7 L'interface MathML, si une application MathML répond à une commande de l'utilisateur de copier une sous-expression MathML dans le presse-papier de l'environnement, tout élément maction présent dans la matière copiée devraient recevoir des attributs de sélection correspondant à l'état de leur sélection dans le rendu MathML au moment de la commande de copie.

On suggère plus loin une liste de valeurs pour l'attribut actiontype et des actions à leur associer. Rappelez-vous toutefois que cette liste sert principalement d'illustration et que les valeurs reconnues et leurs comportements varieront d'une application à l'autre.

<maction actiontype="toggle" selection="positive-integer" > (1ère expression) (2ème expression) ... </maction>
Pour ce type d'action, un moteur de rendu afficherait tour à tour les expressions données, les parcourant jusqu'à ce que le lecteur aura cliqué sur l'expression courante, en commençant par l'expression sélectionnée et en mettant à jour l'attribut selection comme décrit précédemment. Les utilisations typiques concerneraient les exercices éducatifs, les ellipses dans les sorties longues de calculs algébriques ou l'illustration d'autres notations. Remarquez que les dimensions des expressions peuvent être sensiblement différentes de sorte qu'une négociation des dimensions avec le navigateur sera peut-être souhaitable. Si la négociation des dimensions n'est pas disponible, un mécanisme de défilement, d'élision, de mouvement panoramique, ou une autre méthode, sera peut-être nécessaire pour une visualisation entière.
<maction actiontype="statusline"> (expression) (message) </maction>
Dans ce cas, le moteur de rendu afficherait l'expression en contexte à l'écran. Lorsque le lecteur aura cliqué sur l'expression ou déplacé la souris sur elle, le moteur de rendu enverrait un rendu du message dans la barre de statut du navigateur. Comme la plupart des navigateurs dans un futur prévisible se limitera probablement à un texte affiché dans sa barre de statut, les auteurs utiliseront vraisemblablement du texte brut dans un élément mtext pour le message dans la majorité des cas. Pour les messages hors mtext, les moteurs de rendu devraient fournir une traduction du balisage en langue naturelle, mais ce n'est pas obligatoire.
<maction actiontype="tooltip"> (expression) (message) </maction>
Le moteur de rendu afficherait ici aussi l'expression en contexte à l'écran. Quand la souris aura stationné sur l'expression pendant un certain temps, le moteur de rendu affichera un rendu du message dans une infobulle à côté de l'expression. Ces boîtes de message sont parfois appelées bulles d'aide. Les auteurs utiliseront vraisemblablement du texte brut dans un élément mtext pour le message. Pour les messages hors mtext, les moteurs de rendu peuvent fournir une traduction du balisage en langue naturelle si un rendu MathML complet n'est pas réalisable, mais ce n'est pas obligatoire.
<maction actiontype="highlight" my:color="red" my:background="yellow"> expression </maction>
Dans ce cas, le moteur de rendu pourrait mettre en surbrillance l'expression englobée au cours d'un événement souris dessus. Dans cet exemple, on a utilisé des attributs non normalisés issus d'un autre espace de nommage pour passer des informations supplémentaires aux moteurs de rendu qui les gèrent, sans enfreindre la définition DTD de MathML (cf. la section 7.2.3 Les attributs de données non définies). L'attribut my:color change la couleur des caractères dans la présentation, et l'attribut my:background celle de l'arrière-plan des caractères.
<maction actiontype="menu" selection="1" > (item de menu 1) (item de menu 2) ... </maction>
Ce type d'action instruirait le moteur de rendu de fournir un menu déroulant. Cela offre une possibilité de liaison un-à-plusieurs. Remarquez que les items du menu peuvent être d'autres expressions <maction actiontype="menu">...</maction>, autorisant de ce fait des menus imbriqués. On suppose que l'utilisateur choisissant un item de menu invoquera un type d'action associé. Une telle action pourrait être entièrement gérée par le moteur de rendu en question, ou déclencher dans le navigateur un certain type d'événement lié à une autre logique de programmation.

Table des matières : Le langage de balisage mathématique (MathML) version 2.0
Chapitre précédent : 2. Les principes fondamentaux de MathML
Chapitre suivant : 4. Le balisage de contenu