Table des matières : Le langage de balisage mathématique (MathML) version 2.0
Chapitre précédent : B La grammaire de validation du balisage de contenu
Chapitre suivant : D Le modèle objet de document de MathML
Le rôle principal des éléments de contenu MathML consiste à fournir un mécanisme pour rendre compte de la signification mathématique particulière d'une structure de notation particulière. Pour cela, une définition mathématique doit être associée à chaque élément de contenu d'une manière ou d'une autre. Le but de cette annexe est de fournir des définitions par défaut. (On donne un index de ces définitions plus loin dans ce document). Les auteurs peuvent adapter la notation selon leurs besoins particuliers propres en utilisant les mécanismes fournis pour remplacer les définitions par défaut de ces éléments de contenu sélectionnés.
Les définitions mathématiques suivantes ne se restreignent pas à un seul format. Plusieurs justifications à cela, presque toutes découlant de l'importance extrême de permettre aux auteurs de réutiliser les définitions existantes issues de la littérature mathématique :
Les questions cruciales pour des besoins d'archivage et de calcul sont celles concernant l'existence d'une définition
et partant que l'auteur puisse disposer d'un mécanisme permettant d'indiquer que telle définition est prévue pour telle instance
d'une structure de notation. Cette condition est importante, qu'une mise en œuvre d'un concept ou d'un objet particuliers
existent ou non dans un système de calcul mathématique. La définition peut, par exemple, se réduire à une affirmation aussi vague que
F est une fonction inconnue mais dérivable de l'ensemble des réels vers l'ensemble des réels
, ou se compliquer
jusqu'à imposer que F soit une fonction élaborée, ou une opération, telle que définie dans un journal scientifique particulier.
Il importe que le lecteur dispose toujours d'un moyen permettant de déterminer comment la notation est employée.
La décision de l'auteur d'utiliser des éléments de contenu revient à se servir d'objets définis. Des définitions par défaut sont offertes pour faciliter cette décision. Ainsi, l'auteur n'a besoin de fournir des définitions explicites que si l'utilisation diffère de celle définie par défaut. Lorsque c'est possible, les définitions ont naturellement été choisies pour refléter l'utilisation courante.
Les définitions d'une instance particulière se remplacent en utilisant l'attribut definitionURL.
La valeur de cet attribut est une adresse URI
(contrairement à sa dénomination ancienne) dont le format n'est en outre pas défini. La valeur de definitionURL
peut même être un nom inventé par l'auteur. Auquel cas, elle prévient le lecteur (et les systèmes de calcul) de l'utilisation par l'auteur
d'une définition locale privée. Cela peut être l'adresse URL
d'une publication mathématique ou une référence dans une source traditionnelle où la structure est définie. Si l'opérateur mathématique
de l'auteur correspond exactement à l'opérateur d'un système de calcul particulier, un élément MathML semantics
pourrait constituer une définition appropriée permettant d'établir une correspondance entre deux codages. Quel que soit le format choisi,
la seule condition est d'indiquer un certain type de définition.
Le reste de cette annexe fournit les descriptions détaillées des sémantiques associées à chacun des éléments de contenu MathML. Dans la mesure où c'est exactement le rôle attendu des codages en cours de développement par le Consortium OpenMath et que l'un de nos objectifs est de stimuler la coopération dans ces efforts de standardisation, nous avons présenté les définitions par défaut dans un format modelé sur les dictionnaires de contenu OpenMath. Bien que les choses diffèrent en réalité quelque peu de la spécification OpenMath, les principes sous-jacents sont les mêmes.
Beaucoup de définitions fournies ici se rapportent à une ou plusieurs entrées des standards mathématiques de référence que sont le Abramowitz et Stegun [Abramowitz1997] et le Standard Mathematical Tables and Formulae [Zwillinger1988].
MMLdefinitionDans la source XML de cette annexe, chaque élément MathML est décrit à l'aide d'un vocabulaire XML conçu pour cet usage. Par contre, quoique bien adaptée à un traitement mécanique, la forme XML des définitions est difficile à lire par un humain. Le texte à suivre est donc composé automatiquement, d'après des transformations XSL de la source XML (et par composition en ce qui concerne les versions PDF de la spécification MathML), mais formaté pour qu'il soit plus facile à lire et à comprendre. Les conventions employées seront expliquées juste après au fur et à mesure des éléments de balisage de la source XML. La première définition en exemple, mais uniquement celle-ci, sera donnée dans la forme la plus lisible et dans la forme XML brute, afin d'apprécier la différence.
L'élément de premier niveau est MMLdefinition. Les sous-éléments identifient les diverses parties de la description
et comprennent :
PCDATA fournissant le nom de l'élément MathML.CDATA de l'objet représenté par l'élément. Elle fera souvent référence à des textes
ou articles plus traditionnels, ou à des articles existants sur le Web.sep pour séparer les
valeurs CDATA définissant un nombre rationnel en deux parties afin d'en faciliter l'analyse par une application XML.
On désigne ces objets par le terme générique ponctuation.declare sert à réinitialiser les valeurs par défaut des attributs, ou à associer un nom
à l'instance spécifique d'un objet. On désigne ces types d'éléments par le terme générique descripteurs,
et le type de l'objet résultant est le même que celui de l'élément à modifier mais avec les nouvelles valeurs d'attributs.plus et sin. Ces définitions de fonction
sont paramétrées par les valeurs de leurs attributs XML (par exemple, elles peuvent être du type vecteur),
et on les utilise telles quelles, par exemple, pour l'explication des propriétés d'une fonction ou d'un opérateur particuliers,
ou bien on les applique à des arguments à l'aide d'un élément apply. Dans ce dernier cas, on dit qu'il s'agit
d'une application de fonction. Les fonctions sont souvent classées selon leur utilisation. Par exemple, l'élément plus
est un opérateur n-aire. Cette donnée supplémentaire est saisie par la signature. La signature d'une fonction
(cf. ci-dessous) décrit comment utiliser une fonction mathématique au sein d'un élément apply. Chaque combinaison
des types d'arguments de fonction utilisés dans un élément apply établit un élément apply d'un type donné.apply. Leur signature est simplement le type des objets
qu'elles représentent.contiennentdes sous-éléments sont tous des constructeurs d'objets d'un type ou d'un autre. Ils combinent les sous-éléments en un seul objet mathématique composé, tels qu'une constante, un ensemble ou une application de fonction. Par exemple, l'élément
lambda construit une définition de fonction d'après une liste de variables
et une expression, tandis que l'élément apply construit une application de fonction.
Par application de fonction, on entend le résultat de l'application du premier élément de apply (la fonction)
sur zéro à plusieurs éléments restants (les arguments). Une application de fonction représente un objet dans l'ensemble d'arrivée
de la fonction. Pour chaque combinaison donnée de types et d'ordres des sous-éléments XML, la signature
d'un constructeur indique le type (et parfois le sous-type) de l'objet résultant.type de l'élément cn sert à déterminer quel type de constante
(entier, réel, etc.) est construit. Seuls les attributs affectant les propriétés mathématiques d'un objet sont listés ici et, habituellement,
ils apparaissent aussi explicitement dans la signature.apply. Les modificateurs
altèrent les attributs d'un objet existant. Par exemple, un symbole peut devenir un symbole de type vecteur.
La signature doit être capable d'enregistrer des valeurs d'attributs et des types d'arguments spécifiques sur la gauche,
et des types paramétrés sur la droite. La syntaxe utilisée pour les signatures est de la forme générale suivante :
[<nom d'attribut>=<valeur-attribut>]( <liste de types d'arguments> ) --> <type du résultat mathématique>(<sous-type mathématique>)Le cas échéant, les définitions
MMLattribute apparaissent sous la forme <nom>=<valeur>. Elles sont séparées du reste des arguments dans la notation par des crochets. Habituellement, les valeurs possibles proviennent d'une liste énumérée et la signature est affectée par la sélection d'une valeur spécifique. Pour les arguments de fonctions et les paramètres nommés réels à gauche, l'accent est mis sur les types mathématiques impliqués. Les types d'arguments des fonctions sont présentés dans une syntaxe similaire à celle employée pour une définition DTD, à l'exception notable suivante. Les types des paramètres nommés apparaissent dans la signature sous la forme
<nom-de-l'élément>=<type>, analogue à la syntaxe employée pour les valeurs d'attributs. Par exemple, si l'argument est nommé (par exemple,
bvar), alors il est représenté dans la signature par une équation comme dans :
[<nom d'attribut>=<valeur-attribut>]( bvar=symbol,<liste d'arguments> ) --> <type du résultat mathématique>(<sous-type mathématique>)Il n'y a aucun système de typage formel dans MathML. Les valeurs de types utilisées dans les signatures sont les types mathématiques courants, tels que entier, rationnel, réel, complexe (comme dans la description de l'élément
cn), ou un nom, tels qu'une chaîne ou le nom d'un
contructeur MathML. De temps en temps, des collections de types diverses, telles que anything, matrixtype,
sont utilisées. Le nom de type mmlpresentation sert à représenter n'importe quel objet de présentation MathML valide,
et le nom MathMLtype sert à décrire la collection de tous les types MathML. Le type algebraic sert pour
les expressions construites d'après un ou plusieurs symboles au travers d'opérations arithmétiques, et le type interval-type
désigne les types d'intervalles valides, comme définis au chapitre 4. La collection de types n'est pas fermée.
Les utilisateurs écrivant leurs propres définitions de nouvelles structures peuvent introduire des types nouveaux.
Plusieurs signatures peuvent s'appliquer selon les types impliqués. Par exemple, beaucoup d'opérations arithmétiques
impliquant des entiers correspondent aux entiers mais, puisque les entiers sont des nombre réels, la signature des nombres réels
est également valide. En général, la signature offrant le plus d'informations est celle convenant le mieux. Aucune évaluation mathématique
n'intervient jamais dans MathML. Chaque élément de contenu MathML désigne un objet défini, telle qu'une
fonction mathématique, ou bien combine ces objets d'une façon ou d'une autre pour en construire un nouveau. Pour les besoins de signature,
l'objet construit représente un objet d'un certain type paramétré. Par exemple, le résultat de l'application de
l'élément plus à des arguments est une expression représentant une somme. Le type de l'expression résultante
dépend des types des opérandes et des valeurs d'attributs MathML.value,
ou approx (approximation), contenant une description MathML de cette valeur particulière.
On exprime des conditions plus élaborées sur l'objet en utilisant la syntaxe MathML.PCDATA et ils peuvent apparaître comme sous-éléments
de la définition MMLdefinition en n'importe quel point.cnL'élément cn sert à coder des constantes numériques. Le type mathématique du nombre est donné par un attribut.
Le type par défaut est "real". La définition complète des nombres en virgule flottante
en notation scientifique, des rationnels et des complexes nécessite deux parties.
Ces parties sont séparées par un élément sep vide.
Beaucoup de constantes numériques courantes, tel que π, ont leur propre élément.
Cf. également la section 4.4.1.1 Les nombres (cn).
constante
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | integer | rational | complex-cartesian | complex-polar | real | |
real |
| base | entier entre 2 et 36 | 10 |
[type=integer](numstring) -> constant(integer)
[base=base-value](numstring) -> constant(integer)
[type=rational](numstring,numstring) -> constant(rational)
[type=complex-cartesian](numstring,numstring) -> constant(complex)
[type=rational](numstring,numstring) -> constant(rational)
[type=e-notation](numstring,numstring) -> constant(e-notation)
[definitionURL=definition](numstring*) -> constant(user-defined)
<apply><eq/><cn base="16"> A </cn><cn> 10 </cn></apply>
<apply><eq/><cn base="16"> B </cn><cn> 11 </cn></apply>
<apply><eq/><cn base="16"> C </cn><cn> 12 </cn></apply>
<apply><eq/><cn base="16"> D </cn><cn> 13 </cn></apply>
<apply><eq/><cn base="16"> E </cn><cn> 14 </cn></apply>
<apply><eq/><cn base="16"> F </cn><cn> 15 </cn></apply>
<cn> 245 </cn>
<cn type="integer"> 245 </cn>
<cn type="integer" base="16"> A </cn>
<cn type="rational"> 245 <sep/> 351 </cn>
<cn type="complex-cartesian"> 1 <sep/> 2 </cn>
<cn> 245 </cn>
<apply><eq/> <cn type="e-notation"> 2 <sep/> 5 </cn> <apply><times/><cn>2</cn><apply><power/><cn>10</cn><cn>5</cn></apply></apply> </apply>
ciCet élément construit un identificateur (un nom symbolique). L'attribut type sert à indiquer le type de
l'objet défini. Par défaut, l'attribut type vaut "real".
Cf. également la section 4.4.1.2 Les identificateurs (ci).
constructeur
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | constant | matrix | set | vector | list | MathMLtype | real |
({string|mmlpresentation}) -> symbol
[type=typename]({string|mmlpresentation}) -> symbol(typename)
<ci> xyz </ci>
<ci> type="vector"> v </ci>
csymbolL'élément csymbol permet à l'auteur d'introduire des objets nouveaux dans MathML.
Les objets sont liés à des définitions externes au moyen des attribut definitionURL et encoding.
L'élément csymbol devient le nom
du nouvel objet. Les nouveaux objets sont habituellement des constantes
ou bien des fonctions.
Cf. également la section 4.4.1.3 Les symboles à définition externe (csymbol).
constante, fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
[definitionURL=definition]({string|mmlpresentation}) -> defined_symbol
[type=typename]({string|mmlpresentation}) -> defined_symbol(typename)
<csymbol definitionURL=".../mydefinitionofPi">π</csymbol>
applyC'est le constructeur MathML d'application de fonction. Le premier argument est appliqué aux autres arguments. Certains sous-éléments peuvent être des éléments nommés (cf. signature).
Cf. également la section 4.4.2.1 Les applications (apply).
constructeur
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(function,anything*) -> apply
<apply><plus/> <ci>x</ci> <cn>1</cn> </apply>
<apply><sin/> <ci>x</ci> </apply>
relnCe constructeur est déconseillé. L'élément apply remplace reln dans toutes les utilisations.
C'était le constructeur MathML 1.0 pour exprimer une relation entre deux objets mathématiques (ou plus). Le premier argument
indique le type de relation
entre les autres arguments (cf. signature). Aucune hypothèse n'est faite concernant la
valeur de vérité d'une telle relation. Normalement, la relation est utilisée
comme composante de la construction d'une certaine assertion logique. On peut combiner les relations en ensembles, etc.,
comme tout autre objet mathématique.
Cf. également la section 4.4.2.2 Les relations (reln).
constructeur
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(function,anything*) -> reln
Aucun exemple de structure déconseillée n'est fourni.
fnCe constructeur est déconseillé.
C'était le constructeur MathML 1.0 pour construire des fonctions nouvelles. Son rôle consistait à identifier
un objet de contenu MathML général comme étant une fonction, qu'on puisse le définir et l'utiliser dans un contexte
de fonction comme dans apply et declare. On y parvient désormais en utilisant l'attribut definitionURL
et au fait que les éléments declare et apply admettent n'importe quel élément de contenu comme premier argument.
Cf. également la section 4.4.2.3 Les fonctions (fn).
constructeur
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(anything) -> function
[definitionURL=functiondef](anything) ->function
Aucun exemple de structure déconseillée n'est fourni.
intervalC'est l'élément constructeur MathML pour construire un intervalle dans l'ensemble des réels. Quoiqu'on puisse exprimer un intervalle au moyen d'une combinaison appropriée de relations, ils apparaissent ici explicitement en raison de leur utilisation fréquente.
Cf. également la section 4.4.2.4 Les intervalles (interval).
constructeur
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | closed | open | open-closed | closed-open | closed |
[type=interval-type](expression,expression) -> interval(interval-type)
<apply><interval closure="open"/> <ci>x</ci> <cn>1</cn> </apply>
<apply><interval closure="open-closed"/> <cn>0</cn> <cn>1</cn> </apply>
inverseCet élément MathML s'applique à une fonction pour en construire une nouvelle que l'on interprète comme la
fonction symétrique de la fonction originale. Pour une fonction F donnée, la fonction inverse(F) composée avec F
se comporte comme l'application identique sur le domaine de F, et
F composée avec inverse(F) devrait être une fonction identique dans un sous-ensemble restreint approprié
de l'ensemble d'arrivée de F. On devrait utiliser l'attribut definitionURL
de MathML pour résoudre les ambiguïtés de notation, ou pour restreindre le symétrique à un domaine particulier
ou en faire une fonction à sens unique.
Cf. également la section 4.4.2.5 Les symétriques (inverse).
opérateur
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(function) -> function
[definitionURL=URI](function) -> function(definition)
ForAll( y such y in domain( f^(-1)) , f( f^(-1)(y)) = y
<apply><forall/>
<bvar><ci>y</ci></bvar>
<bvar><ci type="function">f</ci></bvar>
<condition>
<apply><in/>
<ci>y</ci>
<apply><csymbol definitionURL="domain"><mtext>Domain</mtext></csymbol>
<apply><inverse/><ci type="function">f</ci></apply>
</apply>
</apply>
</condition>
<apply><eq/>
<apply><ci type="function">f</ci>
<apply><apply><inverse/><ci type="function">f</ci></apply>
<ci>y</ci>
</apply>
</apply>
<ci>y</ci>
</apply>
</apply>
<apply><inverse/> <sin/> </apply>
<apply><inverse definitionURL="www.example.com/MathML/Content/arcsin"/> <sin/> </apply>
sepC'est le constructeur MathML infixe utilisé pour subdiviser des valeurs de type PCDATA
en composants distincts. On l'utilise pour décrire les nombres en plusieurs parties, tels que les rationnels ou les nombres complexes.
Cf. également la section 4.4.2.6 Le séparateur (sep).
ponctuation
<cn type="complex-polar">123<sep/>456</cn>
<cn>123</cn>
conditionC'est le constructeur MathML pour construire des conditions. Une condition diffère d'une relation selon la façon dont on l'utilise. Une relation est simplement une expression, tandis qu'une condition sert comme prédicat pour placer des conditions sur des variables liées.
On peut construire des conditions composées en appliquant des opérateurs, tels que and
ou or
.
Cf. également la section 4.4.2.7 Les conditions (condition).
constructeur
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(apply) -> predicate
<condition>
<apply><lt/>
<apply><power/><ci>x</ci><cn>5</cn></apply>
<cn>3</cn>
</apply>
</condition>
declareC'est le constructeur MathML pour associer des valeurs d'attributs par défaut et des valeurs à des objets mathématiques. Par exemple, V peut être un identificateur déclaré comme étant un vecteur (avoir pour attribut le type vecteur), ou V peut être un nom représentant un vecteur particulier.
Les valeurs d'attributs de la déclaration declare elle-même deviennent les valeurs d'attributs par défaut
du premier argument de l'élément declare.
S'il y a un second argument, le premier argument devient un alias du second, et il en adopte également toutes les propriétés.
Par exemple, l'identificateur v d'un élément ci, déclaré comme étant le vecteur (1,2,3), apparaîtrait
dans un style de vecteur et sa norme serait celle de (1,2,3).
Cf. également la section 4.4.2.8 Les déclarations (declare).
modificateur
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLtype | aucune |
| nargs | nombre d'arguments d'un objet d'opérateur | * |
| occurrence | infix | prefix | prefix |
[(attributename=attributevalue)*](anything) -> [(attributename=attributevalue)*](anything)
[(attributename=attributevalue)*](anything,anything) -> [(attributename=attributevalue)*](anything)
(anything,anything) -> (anything)
<declare> <ci>y</ci> <apply><plus/><ci>x</ci><cn>3</cn></apply> </declare>
<declare type="vector"> <ci> V </ci> </declare>
<declare type="vector"> <ci> V </ci> <vector><cn> 1 </cn><cn> 2 </cn><cn> 3 </cn></vector> </declare>
lambdaC'est l'opération de lambda calcul pour construire une fonction d'après une expression et une variable.
La fonction lambda est une fonction n-aire, dans laquelle tous les arguments sauf le dernier sont des variables liées, le
dernier argument étant une expression impliquant éventuellement ces variables. On peut assimiler la fonction lambda
à l'inverse d'une application de fonction.
Par exemple, Lambda( x, F ) s'écrit \lambda x [F]
dans la littérature du lambda calcul. L'expression F peut contenir
x mais l'expression lambda complète est vue comme libre de x. Une application de calcul recevant une expression
lambda MathML ne devrait pas évaluer x ou faire de test pour x. Une telle application
peut appliquer l'expression lambda comme une fonction à des arguments, auquel cas tout résultat calculé l'est par des remplacements
de paramètres dans F.
Remarquez qu'une expression lambda sur une fonction arbitraire appliquée à un argument simple équivaut à cette fonction arbitraire.
Cf. également la section 4.4.2.9 La construction lambda (lambda).
constructeur
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(bvar*,anything) -> function
ForAll( F , lambda(x,F(x)) = F)
<apply><forall/>
<bvar><ci>F</ci></bvar>
<apply><eq/>
<lambda>
<bvar><ci>x</ci></bvar>
<apply><ci>F</ci><ci>x</ci></apply>
</lambda>
<ci>F</ci>
</apply>
</apply>
<lambda> <bvar><ci>x</ci></bvar> <apply><sin/><apply><plus/><ci> x </ci><cn> 3 </cn></apply></apply> </lambda>
composeC'est le constructeur MathML pour la composition des fonctions. Pour qu'une composition soit significative, l'ensemble d'arrivée de la première fonction devrait être le domaine de la seconde, etc. Toutefois, puisqu'aucune évaluation n'intervient dans MathML, on peut utiliser sans risque cette structure pour faire des déclarations, telle que f composée par g ne soit pas définie.
Le résultat est une nouvelle fonction dont le domaine est celui de la première fonction et l'ensemble d'arrivée celui de la dernière fonction, et dont la définition équivaut à appliquer chaque fonction à son tour sur la sortie de la précédente, comme dans :
( f @ g )( x ) == f( g(x) )
Cette fonction est souvent indiquée par un opérateur infixe ayant la forme d'un petit cercle.
Cf. également la section 4.4.2.10 La composition des fonctions (compose).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(function*) -> function
ForAll(x, (f@g)(x) = f(g(x))
<apply><forall/>
<bvar><ci>x</ci></bvar><bvar><ci>f</ci></bvar><bvar><ci>g</ci></bvar>
<apply><eq/>
<apply><apply><compose/><ci>f</ci><ci>g</ci></apply>
<ci>x</ci>
</apply>
<apply><ci>f</ci><apply><ci>g</ci><ci>x</ci></apply></apply>
</apply>
</apply>
L'utilisation de l'élément fn est déconseillée : utilisez l'attribut type="function" à la place.
<apply><compose/> <ci type="function"> f </ci> <ci type="function"> g </ci> <sin/> </apply>
identL'élément ident représente l'application identique.
MathML ne fait aucune hypothèse pour l'espace de fonctions dans lequel réside l'application identique.
L'interprétation exacte du domaine de l'application identique (et donc de son ensemble d'arrivée) dépend du contexte où elle est utilisée.
Cf. également la section 4.4.2.11 L'application identique (ident).
constructeur
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
fonction
ForAll(x, ident(x) = x )
<apply><forall/>
<bvar><ci>x</ci></bvar>
<apply><eq/>
<apply><ident/><ci>x</ci></apply>
<ci>x</ci>
</apply>
</apply>
<apply><eq/>
<apply><compose/>
<ci type="function"> f </ci>
<apply><inverse/><ci type="function"> f </ci>
</apply>
</apply>
<ident/>
</apply>
domainL'élément domain indique le domaine d'une fonction donnée, c'est-à-dire l'ensemble des valeurs pour lesquelles
celle-ci est définie.
Pour remplacer la sémantique par défaut de cet élément,
ou pour lui associer une définition plus spécifique, utilisez les attributs definitionURL et encoding.
Cf. également la section 4.4.2.12 Le domaine (domain).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(function) -> set
<apply><eq/> <apply><domain/><ci>f</ci></apply> <reals/> </apply>
codomainL'élément codomain désigne l'ensemble d'arrivée d'une fonction donnée, c'est-à-dire l'ensemble contenant
toutes les valeurs prises par la fonction. L'ensemble d'arrivée peut contenir d'autres points non obtenus par l'application
de la fonction sur les éléments du domaine.
Pour remplacer la sémantique par défaut de cet élément, ou pour lui associer une définition plus spécifique,
utilisez les attributs definitionURL et encoding.
Cf. également la section 4.4.2.13 L'ensemble d'arrivée (codomain).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(function) -> set
ForAll(y, y =f(x) , member(y,codomain(f)))
<apply><eq/> <apply><codomain/><ci>f</ci></apply> <rationals/> </apply>
imageL'élément image indique l'image d'une fonction donnée, c'est-à-dire l'ensemble des valeurs que celle-ci prend.
Chaque point de l'image est généré par la fonction appliquée à un certain point du domaine.
Pour remplacer la sémantique par défaut de cet élément, ou pour lui associer une définition plus spécifique,
utilisez les attributs definitionURL et encoding.
Cf. également la section 4.4.2.14 L'image (image).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(function) -> set
ForAll(x, x in codomain(f) , ThereExists(y,f(y)=x))
<apply><eq/> <apply><image/><sin/></apply> <interval><cn>-1</cn><cn> 1</cn></interval> </apply>
domainofapplicationL'élément domainofapplication indique le domaine sur lequel une fonction donnée est appliquée.
Il constitue une alternative plus générale à la définition de ce domaine en utilisant des éléments quantificateurs,
tels que bvar, lowlimit ou condition.
Pour remplacer la sémantique par défaut de cet élément, ou pour lui associer
une définition plus spécifique, utilisez les attributs definitionURL et encoding.
Cf. également la section 4.4.2.15 Le domaine d'application (domainofapplication).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(function) -> set
<apply><int/> <domainofapplication><ci>C</ci></domainofapplication> <ci>f </ci> </apply>
piecewiseLes éléments piecewise, piece et otherwise sont utilisés pour gérer les déclarations
en morceaux
(N.d.T. piecewise) de la forme H(x) = 0, si x est inférieur à 0, sinon H(x) = 1.
Les éléments piece et otherwise décrivent des règles d'évaluation. Si aucune règle ne s'applique,
ou si plusieurs règles s'appliquent mais donnant des réponses différentes, alors l'expression n'est pas définie.
Pour remplacer la sémantique par défaut de cet élément, ou pour lui associer une définition plus spécifique,
utilisez les attributs definitionURL et encoding.
Cf. également la section 4.4.2.16 Les déclarations en morceaux (piecewise, piece, otherwise).
constructeur
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(piece*,otherwise) -> algebraic
ForAll(x, x in domain(f) , les règles d'évaluation produisent collectivement une valeur au plus dans codomain(f))
<piecewise> <piece><cn> 0</cn><apply><lt/><ci> x</ci> <cn> 0</cn></apply></piece> <otherwise><ci>x</ci></otherwise> </piecewise>
La valeur de la fonction abs évaluée sur x peut s'écrire :
<piecewise>
<piece>
<apply><minus/><ci>x</ci></apply>
<apply><lt/><ci> x</ci><cn> 0</cn></apply>
</piece>
<piece>
<cn>0</cn>
<apply><eq/><ci>x</ci><cn>0</cn></apply>
</piece>
<piece>
<ci>x</ci>
<apply><gt/><ci>x</ci><cn>0</cn></apply>
</piece>
</piecewise>
pieceL'élément piece sert à construire les valeurs définies conditionnellement qui font partie d'un objet piecewise.
Pour remplacer la sémantique par défaut de cet élément, ou pour lui associer une définition plus spécifique,
utilisez les attributs definitionURL et encoding.
Cf. également la section 4.4.8.1 Les fonctions trigonométriques courantes.
constructeur
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(algebraic,boolean) -> piece
<piecewise> <piece><cn>0</cn><apply><lt/><ci> x</ci> <cn> 0</cn></apply></piece> <otherwise><ci>x</ci></otherwise> </piecewise>
otherwiseL'élément otherwise sert à décrire la valeur d'une structure piecewise
quand aucune des conditions piece associées n'est satisfaite.
Pour remplacer la sémantique par défaut de cet élément, ou pour lui associer une définition plus spécifique,
utilisez les attributs definitionURL et encoding.
Cf. également la section 4.4.8.1 Les fonctions trigonométriques courantes.
constructeur
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(algebraic) -> algebraic
<piecewise> <piece><cn> 0</cn><apply><lt/><ci> x</ci> <cn> 0</cn></apply></piece> <otherwise><ci>x</ci></otherwise> </piecewise>
quotientLa fonction quotient est la fonction binaire qui sert à représenter l'opération de division entière.
L'expression quotient(a,b) indique q, tel que a = b * q + r,
avec |r| inférieur à |b| et a * r positif.
Cf. également la section 4.4.3.1 Le quotient (quotient).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | integer |
(integer, integer) -> integer
forall([a,b], b != 0, a = b*quotient(a,b) + rem(a,b)
<apply><forall/>
<bvar><ci>a</ci></bvar>
<bvar><ci>b</ci></bvar>
<condition><apply><neq/><ci>b</ci><cn>0</cn></apply></condition>
<apply><eq/>
<ci>a</ci>
<apply><plus/>
<apply><times/>
<ci>b</ci>
<apply><quotient/><ci>a</ci><ci>b</ci></apply>
</apply>
<apply><rem/><ci>a</ci><ci>b</ci></apply>
</apply>
</apply>
</apply>
<apply><quotient/> <ci> a </ci> <ci> b </ci> </apply>
<apply> <quotient/> <cn>5</cn> <cn>4</cn> </apply>
factorialC'est l'opérateur unaire qui sert à construire des factorielles. Les factorielles sont définies par n! = n * (n-1) * ... * 1.
Cf. également la section 4.4.3.2 Les factorielles (factorial).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | integer |
( algebraic ) -> algebraic
(integer)->integer
ForAll(n,n \gt 0, n! = n*(n-1)!)
<apply><forall/>
<bvar><ci>n</ci></bvar>
<condition><apply><gt/><ci>n</ci><cn>0</cn></apply></condition>
<apply><eq/>
<apply><factorial/><ci>n</ci></apply>
<apply><times/>
<ci>n</ci>
<apply><factorial/>
<apply><minus/><ci>n</ci><cn>1</cn></apply>
</apply>
</apply>
</apply>
</apply>
0! = 1
<apply></eq> <apply><factorial/><cn>0</cn></apply> <cn>1</cn> </apply>
<apply><factorial/> <ci>n</ci> </apply>
divideC'est l'opérateur MathML binaire utilisé pour indiquer l'opération mathématique divisé par
.
Cf. également la section 4.4.3.3 La division (divide).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | real |
(complex, complex) -> complex
(real, real) -> real
(rational, rational) -> rational
(integer, integer) -> rational
Erreur de division par zéro
<apply><forall/>
<bvar><ci>a</ci></bvar>
<apply><eq/>
<apply><divide/><ci> a </ci><ci> 0 </ci>
<notanumber/>
</apply>
</apply>
</apply>
ForAll( a , a!= 0, a/a = 1)
<apply><forall/>
<bvar><ci>a</ci></bvar>
<condition><apply><neq/><ci>a</ci><cn>0</cn></apply></condition>
<apply><eq/>
<apply><divide/><ci>a</ci><ci>a</ci></apply>
<cn>1</cn>
</apply>
</apply>
<apply><divide/> <ci> a </ci> <ci> b </ci> </apply>
maxC'est l'opérateur n-aire utilisé pour représenter le maximum dans un ensemble d'éléments. Les éléments peuvent être listés explicitement, ou bien décrits par une condition ; par exemple, le maximum de tous les x de l'ensemble A.
Cf. également la section 4.4.8.1 Les fonctions trigonométriques courantes.
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | real |
( ordered_set_element * ) -> ordered_set_element
( bvar,condition,anything ) -> anything
ForAll(x in S, max(y in S,y) \geq x )
Le maximum d'une liste finie d'éléments.
<apply><max/><cn>2</cn><cn>3</cn><cn>5</cn></apply>
Max(y^3, y in (0,1))
<apply> <max/> <bvar><ci>y</ci></bvar> <condition> <apply><in/><ci>y</ci><interval><cn>0</cn><cn>1</cn></interval></apply> </condition> <apply><power/><ci> y</ci><cn>3</cn></apply> </apply>
minC'est l'opérateur n-aire utilisé pour représenter le minimum dans un ensemble d'éléments. Les éléments peuvent être listés explicitement, ou bien décrits par une condition ; par exemple, le minimum de tous les x dans l'ensemble A.
Les éléments doivent tous être comparables pour que le résultat soit bien défini.
Cf. également la section 4.4.8.1 Les fonctions trigonométriques courantes.
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | real |
( ordered_set_element * ) -> ordered_set_element
( bvar,condition,anything ) -> ordered_set_element
Le minimum d'une liste finie d'éléments.
<apply><min/><cn>2</cn><cn>3</cn><cn>5</cn></apply>
min(y^2, y in (0,1))
<apply> <min/> <bvar><ci>y</ci></bvar> <condition> <apply><in/><ci>y</ci><interval><cn>0</cn><cn>1</cn></interval></apply> </condition> <apply><power/><ci> y</ci><cn>2</cn></apply> </apply>
minusC'est l'opérateur de soustraction pour un groupe additif.
Si un argument est fourni, cet opérateur construit le symétrique additif de cet élément de groupe. Pour deux arguments a et b, il construit l'expression mathématique a - b.
Cf. également la section 4.4.3.5 La soustraction (minus).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | real |
(real) -> real
(real,real) -> real
[type=MathMLtype](MathMLtype) -> MathMLtype
[type=MathMLtype](MathMLtype,MathMLtype) -> MathMLtype
(set,set) -> set
(multiset,multiset)->multiset
ForAll(x,x-x=0)
<apply><forall/>
<bvar><ci> x </ci></bvar>
<apply><eq/>
<apply><minus/><ci> x </ci><ci> x </ci></apply>
<cn>0</cn>
</apply>
</apply>
<apply><minus/> <cn>3</cn> <cn>5</cn> </apply>
<apply><minus/> <cn>3</cn> </apply>
plusC'est l'opérateur d'addition n-aire d'une structure algébrique. Si aucun opérande n'est fourni, l'expression représente l'identique additif. Si un opérande a est fourni, l'expression est évaluée à "a". Si deux opérandes (ou plus) sont fournis, l'expression représente l'élément de (demi-)groupe correspondant au couplage binaire associatif à gauche des opérandes. La signification des types d'opérandes mixtes, non couverts par les signatures présentées ici, est laissée à l'initiative du système cible.
Pour des règles de transtypage différentes de celles indiquées
par les signatures, utilisez l'attribut definitionURL afin d'identifier la nouvelle définition.
Cf. également la section 4.4.3.6 L'addition (plus).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | real |
[type=MathMLtype](anything*) -> MathMLtype
(set*)->set
(multiset*)->multiset
(real*)->real
(complex*)->complex
(integer*)->integer
Une somme sans terme est nulle.
<apply><eq/> <apply><plus/></apply> <cn>0</cn> </apply>
La somme d'un seul terme est égale à celui-ci.
<apply><forall/>
<bvar><ci>a</ci></bvar>
<apply><eq/>
<apply><plus/><ci>a</ci></apply>
<cn>a</cn>
</apply>
</apply>
commutative
<apply><forall/>
<bvar><ci>a</ci></bvar>
<bvar><ci>b</ci></bvar>
<condition>
<apply><and/>
<apply><in/><ci>a</ci><reals/></apply>
<apply><in/><ci>b</ci><reals/></apply>
</apply>
</condition>
<apply><eq/>
<apply><plus/><ci>a</ci><ci>b</ci></apply>
<apply><plus/><ci>b</ci><ci>a</ci></apply>
</apply>
</apply>
<apply><plus/> <cn>3</cn> </apply>
<apply><plus/> <cn>3</cn> <cn>5</cn> </apply>
<apply><plus/> <cn>3</cn> <cn>5</cn> <cn>7</cn> </apply>
powerC'est l'opérateur d'élévation à une puissance qui sert à construire les expressions, telle que a (à la) puissance
b.
En particulier, c'est l'opération pour laquelle a (à la) puissance 2
équivaut à a * a.
Cf. également la section 4.4.3.7 L'exponentiation (power).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | real |
(complex, complex) -> complex
(real, real) -> complex
(rational, integer) -> rational
(integer, integer) -> rational
[type=MathMLtype](anything,anything) -> MathMLtype
ForAll(a,a!=0,a^0=1)
<apply><forall/>
<bvar><ci>a</ci></bvar>
<condition><apply><neq/><ci>a</ci><cn>0</cn></apply></condition>
<apply><eq/>
<apply><power/><ci>a</ci><cn>0</cn></apply>
<cn>1</cn>
</apply>
</apply>
ForAll(a,a^1=a)
<apply><forall/>
<bvar><ci>a</ci></bvar>
<apply><eq/>
<apply><power/><ci>a</ci><cn>1</cn></apply>
<ci>a</ci>
</apply>
</apply>
ForAll(a,1^a=1)
<apply><forall/>
<bvar><ci>a</ci></bvar>
<apply><eq/>
<apply><power/><cn>1</cn><ci>a</ci></apply>
<cn>1</cn>
</apply>
</apply>
<apply><power/><cn>2</cn><ci>x</ci></apply>
<apply><power/><ci> x </ci><cn> 3 </cn></apply>
remC'est l'opérateur binaire qui sert à représenter le reste entier de a mod b
.
Pour les arguments a et b, tels que a = b * q + r, avec |r| < |b|, il représente la valeur r.
Cf. également la section 4.4.3.8 Le reste (rem).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | integer |
(integer, integer) -> integer
[type=MathMLtype](MathMLtype,MathMLtype)->MathMLtype
L'expression rem(a, 0) n'est pas définie.
ForAll([a,b],b!=0,a = b*quotient(a,b) + rem(a,b))
<apply><forall/> <bvar><ci>a</ci></bvar> <bvar><ci>b</ci></bvar> <condition><apply><neq/><ci>b</ci><cn>0</cn></apply></condition> <apply><eq/> <ci>a</ci> <apply><plus/> <apply><times/> <ci>b</ci> <apply><quotient/><ci>a</ci><ci>b</ci></apply> </apply> <apply><rem/> <ci>a</ci> <ci>b</ci> </apply> </apply> <apply/> </apply>
<apply><rem/><ci> a </ci><ci> b </ci></apply>
timesC'est l'opérateur de multiplication n-aire pour un anneau. Si aucun argument n'est fourni, alors cela représente l'identique de la multiplication. Si un argument est fourni, cela représente une expression qui serait évaluée à ce seul argument.
Cf. également la section 4.4.3.9 La multiplication (times).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | real |
(complex*) -> complex
(real*) -> real
(rational*) -> rational
(integer*) -> integer
ForAll([a,b],condition(in({a,b},Commutative)),a*b=b*a)
ForAll([a,b,c],Associative,a*(b*c)=(a*b)*c), associativité
L'identique de la multiplication.
<apply><forall/> <bvar><ci>a</ci></bvar> <apply><eq/> <apply><times/><cn>1</cn><ci>a</ci></apply> <ci>a</ci> </apply> </apply>
a * 0 = 0
Commutativité
<apply><forall/> <bvar><ci>a</ci></bvar> <bvar><ci>b</ci></bvar> <condition> <apply><and/> <apply><in/><ci>a</ci><reals/></apply> <apply><in/><ci>b</ci><reals/></apply> </apply> </condition> <apply><eq/> <apply><times/><ci>a</ci><ci>b</ci></apply> <apply><times/><ci>b</ci><ci>a</ci></apply> </apply> </apply>
a * 0 = 0
<apply><forall/> <bvar><ci>a</ci></bvar> <apply><eq/> <apply><times/><cn>0</cn><ci>a</ci></apply> <cn>0</cn> </apply> </apply>
<apply> <times/> <ci> a </ci> <ci> b </ci> </apply>
rootC'est l'opérateur binaire qui sert à contruire la racine nème d'une expression.
Le premier argument a
représente l'expression et le second n
indique la racine,
comme dans ( a ) ^ (1/n)
Cf. également la section 4.4.3.10 Les racines (root).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | real | complex | principal_branch | MathMLtype | real |
( anything , anything) -> root
ForAll(bvars(a,n),root(a,n) = a^(1/n))
La racine nème de a
<apply><root/> <ci> a </ci> <ci> n </ci> </apply>
gcdC'est l'opérateur n-aire qui sert à construire l'expression représentant le plus grand commun diviseur de ses arguments. Si aucun argument n'est fourni, le p.g.c.d. vaut 0. Si un argument est fourni, le p.g.c.d. est cet argument.
Cf. également la section 4.4.3.11 Le plus grand commun diviseur (gcd).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | integer |
[type=MathMLtype](MathMLtype*) ->MathMLtype
(integer*) -> integer
<apply><forall/> <forall/> <bvar><ci>x</ci></bvar> <apply><eq/> <apply><gcd/> <ci>x</ci> <cn>1</cn> </apply> <cn>1</cn> </apply> </apply>
<apply><gcd/> <cn>12</cn> <cn>17</cn> </apply>
<apply><gcd/> <cn>3</cn> <cn>5</cn> <cn>7</cn> </apply>
andC'est l'opérateur logique n-aire et
. Il sert à construire l'expression logique qui, si elle était évaluée,
aurait la valeur de vérité vrai
si tous ses opérandes avaient la valeur de vérité vrai
, et faux
sinon.
Cf. également la section 4.4.3.12 Et (and).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | boolean |
(boolean*) -> boolean
forall(p,(true and p = p )
forall([p,q],(p and q = q and p ))
x and not(x) = false
<apply><and/> <ci>p</ci> <ci>q</ci> </apply>
orC'est l'opérateur logique n-aire ou
. L'expression construite a la valeur de vérité vrai
si au moins un de ses arguments est vrai.
Cf. également la section 4.4.3.13 Ou (or).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | boolean |
(boolean*) -> boolean
[type="boolean"](symbolic*) -> boolean
<apply> <or/> <ci> a </ci> <ci> b </ci> </apply>
xorC'est l'opérateur logique n-aire ou exclusif
. L'expression construite a la valeur de vérité vrai
si un nombre impair de ses arguments sont vrais.
Cf. également la section 4.4.3.14 Ou exclusif (xor).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | boolean |
(boolean*) -> boolean
[type="boolean"](symbolic*) -> symbolic
x xor x = false
x xor not(x) = true
<apply> <xor/> <ci> a </ci> <ci> b </ci> </apply>
notC'est l'opérateur logique unaire non
. Il nie la valeur de vérité de son seul argument ; par exemple,
non P est vrai lorsque P est faux, et faux lorsque P est vrai.
Cf. également la section 4.4.3.15 Non (not).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | boolean |
(boolean) -> boolean
[type="boolean"](algebraic) -> boolean
<apply> <not/> <ci> a </ci> </apply>
impliesC'est l'opérateur binaire implique
. Il sert à construire l'expression logique A implique
B.
Cf. également la section 4.4.3.16 Implique (implies).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | boolean |
(boolean,boolean) -> boolean
faux implique x
<apply> <implies/> <ci> A </ci> <ci> B </ci> </apply>
forallL'opérateur forall est le quantificateur logique pour tous les
. Les variables liées, le cas échéant,
apparaissent en premier et sont balisées avec des éléments bvar. Suit, en option, une condition sur les variables liées.
Le dernier argument est l'expression booléenne affirmée comme étant vraie pour toutes les valeurs des variables liées correspondant
aux conditions indiquées (le cas échéant).
Cf. également la section 4.4.3.17 Le quantificateur universel (forall).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | boolean |
(bvar*,condition?,apply) -> boolean
(bvar*,condition?,(reln)) -> boolean
<apply> <forall/> <bvar><ci> x </ci></bvar> <apply><eq/> <apply> <minus/><ci> x </ci><ci> x </ci> </apply> <cn>0</cn> </apply> </apply>
existsC'est l'opérateur MathML qui sert à affirmer une existence, comme dans l'expression Il existe x tel que x soit réel et x soit positif
.
- Le premier argument indique la variable liée,
- Le deuxième argument optionnel place des conditions sur cette variable liée,
- Le dernier argument est l'expression affirmée comme étant vraie.
Cf. également la section 4.4.3.18 Le quantificateur existentiel (exists).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | boolean |
(element,set) ->boolean
<apply><exists/>
<bvar><ci>x</ci></bvar>
<apply><eq/>
<apply><ci>f</ci>
<ci>x</ci>
</apply>
<cn>0</cn>
</apply>
</apply>
absUn opérateur unaire qui représente la valeur absolue de son argument. Dans le cas d'un nombre complexe, il est souvent désigné par le nom de module.
Cf. également la section 4.4.3.19 La valeur absolue (abs).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | real |
(real)->real
(complex)->real
for all x and y, abs(x) + abs(y) >= abs(x+y)
<apply><abs/><ci>x</ci></apply>
conjugateL'opérateur arithmétique unaire conjugate sert à représenter la
conjuguée complexe de son argument.
Cf. également la section 4.4.3.20 La conjugaison complexe (conjugate).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(algebraic) -> algebraic
(complex)->complex
<apply><conjugate/>
<apply><plus/>
<ci> x </ci>
<apply><times/>
<imaginaryi/>
<ci> y </ci>
</apply>
</apply>
</apply>
argL'opérateur unaire arg sert à construire l'expression représentant
l'argument
d'un nombre complexe.
Cf. également la section 4.4.3.21 L'argument (arg).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | real |
(complex)->real
<apply><arg/>
<apply><plus/>
<ci> x </ci>
<apply><times/><imaginaryi/><ci>y</ci></apply>
</apply>
</apply>
realUn opérateur unaire qui sert à construire l'expression représentant la partie réelle
d'un nombre complexe.
Cf. également la section 4.4.3.22 La partie réelle (real).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | real |
(complex)->real
ForAll(x,y, x in R, Y in R, real(x+i*y)=x)
<apply><forall/>
<bvar><ci>x</ci></bvar>
<bvar><ci>y</ci></bvar>
<apply><eq/>
<apply><real/>
<apply><plus/>
<ci> x </ci>
<apply><times/><imaginaryi/><ci>y</ci></apply>
</apply>
</apply>
<ci> x </ci>
</apply>
</apply>
<apply><real/>
<apply><plus/>
<ci> x </ci>
<apply><times/><imaginaryi/><ci>y</ci></apply>
</apply>
</apply>
imaginaryUne fonction unaire qui sert à construire l'expression représentant la partie imaginaire d'un nombre complexe.
Cf. également la section 4.4.3.23 La partie imaginaire (imaginary).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | real |
(complex)->real
forall([x,y],Imaginary(x + i*y) = y )
<apply><forall/>
<bvar><ci>x</ci></bvar>
<bvar><ci>y</ci></bvar>
<apply><eq/>
<apply><imaginary/>
<apply><plus/>
<ci> x </ci>
<apply><times/><imaginaryi/><ci>y</ci></apply>
</apply>
</apply>
<ci> y </ci>
</apply>
</apply>
<apply><imaginary/>
<apply><plus/>
<ci> x </ci>
<apply><times/><imaginaryi/><ci>y</ci></apply>
</apply>
</apply>
lcmCet opérateur n-aire sert à construire l'expression représentant le plus petit commun multiple de ses arguments. Si aucun argument n'est fourni, le p.p.c.m. vaut 1. Si un argument est fourni, le p.p.c.m. est cet argument. Le p.p.c.m. de x et 1 est x.
Cf. également la section 4.4.3.24 Le plus petit commun multiple (lcm).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | integer |
[type=MathMLtype](MathMLtype*) ->MathMLtype
(integer*) -> integer
(algebraic*) -> algebraic
ForAll(x,lcm(x,1)=x)
<apply><forall/> <bvar><ci>x</ci></bvar> <apply><eq/> <apply><lcm/><ci>x</ci><cn>1</cn></apply> <ci>x</ci> </apply> </apply>
<apply><lcm/> <cn>12</cn> <cn>17</cn> </apply>
<apply><lcm/> <cn>3</cn> <cn>5</cn> <cn>7</cn> </apply>
floorL'élément floor sert à indiquer l'opérateur d'arrondi inférieur
(vers l'infini négatif).
Cf. également la section 4.4.3.25 L'arrondi inférieur (floor).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | integer |
(real) -> integer
[type=MathMLtype](orderedset_element) -> orderedset_element
ForAll(x,floor(x) <= x)
<apply><forall/>
<bvar><ci>x</ci></bvar>
<apply><leq/>
<apply><floor/>
<ci>x</ci>
</apply>
<ci>x</ci>
</apply>
</apply>
<apply> <floor/> <ci> a </ci> </apply>
ceilingL'élément ceiling sert à indiquer l'opérateur d'arrondi supérieur
(vers l'infini positif).
Cf. également la section 4.4.3.26 L'arrondi supérieur (ceiling).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | integer |
(real) -> integer
[type=MathMLtype](orderedset_element) -> orderedset_element
ForAll(x,ceiling(x) >= x)
<apply><forall/>
<bvar><ci>x</ci></bvar>
<apply><geq/>
<apply><ceiling/>
<ci>x</ci>
</apply>
<ci>x</ci>
</apply>
</apply>
<apply> <ceiling/> <ci> a </ci> </apply>
eqCette fonction n-aire sert à indiquer que deux quantités (ou plus) sont égales. Il doit y avoir au moins deux arguments.
Cf. également la section 4.4.4.1 Égal à (eq).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(real,real+) -> boolean
(boolean, boolean+) -> boolean
(set,set+) -> set
(multiset,multiset+) -> multiset
symétrique
transitive
réflexive
<apply><eq/><cn type="rational">2<sep/>4</cn><cn type="rational">1<sep/>2</cn></apply>
<apply><eq/><ci type="set">A</ci><ci type="set">B</ci></apply>
<apply><eq/><ci type="multiset">A</ci><ci type="multiset">B</ci></apply>
neqCette fonction binaire représente la relation non égal à
, qui renvoie vrai sauf si les deux arguments sont égaux.
Cf. également la section 4.4.4.2 Non égal à (neq).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(real,real) -> boolean
(boolean,boolean)-> boolean
(set,set) -> set
(multiset,multiset) -> multiset
symétrique
<apply><neq/><cn>3</cn><cn>4</cn></apply>
gtCette fonction n-aire représente la relation supérieur à
, qui renvoie vrai si chaque argument est, à son tour, supérieur à
celui qui le suit. Il doit y avoir au moins deux arguments.
Cf. également la section 4.4.4.3 Supérieur à (gt).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(real,real+) -> boolean
transitive
<apply><gt/><cn>3</cn><cn>2</cn></apply>
ltCette fonction n-aire représente la relation inférieur à
, qui renvoie vrai si chaque argument est, à son tour, inférieur à
celui qui le suit. Il doit y avoir au moins deux arguments.
Cf. également la section 4.4.4.4 Inférieur à (lt).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(real,real+) -> boolean
transitive
<apply><lt/><cn>2</cn><cn>3</cn><cn>4</cn></apply>
geqCet élément représente la fonction n-aire supérieur ou égal à
, qui renvoie vrai si chaque argument est, à son tour,
supérieur ou égal à celui qui le suit. Il doit y avoir au moins deux arguments.
Cf. également la section 4.4.4.5 Supérieur ou égal à (geq).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(real,real+) -> boolean
transitive
réflexive
<apply><geq/><cn>4</cn><cn>3</cn><cn>3</cn></apply>
leqCette fonction n-aire représente la relation inférieur ou égal à
, qui renvoie vrai si chaque argument est, à son tour,
inférieur ou égal à celui qui le suit. Il doit y avoir au moins deux arguments.
Cf. également la section 4.4.4.6 Inférieur ou égal à (leq).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(real,real+) -> boolean
transitive
réflexive
<apply><leq/><cn>3</cn><cn>3</cn><cn>4</cn></apply>
equivalentCet élément représente la fonction n-aire d'équivalence logique, pour laquelle deux valeurs booléenne sont dites équivalentes si leurs valeurs de vérité sont égales pour tous les choix de valeurs des variables booléennes apparaissant dans celles-ci.
Cf. également la section 4.4.4.7 Équivalent à (equivalent).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(logical,logical+) -> boolean
symétrique
transitive
réflexive
<apply><equivalent/>
<ci>a</ci>
<apply><not/>
<apply<not/><ci>a</ci></apply>
</apply>
<apply>
approxCet élément sert à indiquer que deux quantités (ou plus) sont approximativement égales. Si une définition plus précise
d'approximativement égal à
est nécessaire, on devrait utiliser l'attribut definitionURL pour identifier
la définition qui convient.
Cf. également la section 4.4.4.8 Approximativement égal à (approx).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLType | real |
(real,real+) -> boolean
symétrique
transitive
réflexive
<apply><approx/><pi/><cn type="rational">22<sep/>7</cn></apply>
factorofC'est l'opérateur binaire MathML qui sert à indiquer la relation mathématique a est facteur de
b.
Cette relation est vraie seulement si b mod a = 0.
Cf. également la section 4.4.4.9 Facteur de (factorof).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | MathMLtype | integer |
(integer, integer) -> boolean
ForAll( a,b a et b entiers, a divise b s'il y a un entier c tel que a*c = b)
<apply><factorof/> <ci> a </ci> <ci> b </ci> </apply>
intL'intégrale définie ou indéfinie d'une fonction ou d'une expression algébrique. Il existe plusieurs formes de séquences d'appel, selon la nature des arguments et qu'il s'agisse ou non d'une intégrale définie.
Cf. également la section 4.4.5.1 L'intégration (int).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(function) -> function
(bvar,algebraic) -> algebraic
(bvar,interval,algebraic) -> algebraic
(bvar,condition,algebraic) -> algebraic
(bvar,lowlimit,uplimit,algebraic) -> algebraic
<apply><int/> <bvar><ci> x </ci></bvar> <lowlimit><cn> 0 </cn></lowlimit> <uplimit><ci> a </ci></uplimit> <apply><ci> f </ci><ci> x </ci></apply> </apply>
<apply><int/> <bvar><ci> x </ci></bvar> <interval><ci> a </ci><ci> b </ci></interval> <apply><cos/><ci> x </ci></apply> </apply>
<apply><int/>
<bvar><ci> x </ci></bvar>
<condition>
<apply><in/><ci> x </ci><ci type="set"> D </ci></apply>
</condition>
<apply><ci type="function"> f </ci><ci> x </ci></apply>
</apply>
diffCet élément apparaît sous deux formes : l'une pour les fonctions et l'autre pour les expressions impliquant une variable liée.
Pour les expressions dans la variable liée x, l'expression à différencier suit la variable liée.
S'il n'y a qu'un seul argument (une fonction), l'application de diff sur celui-ci résulte en une nouvelle fonction,
la dérivée de f, souvent notée f'.
Cf. également la section 4.4.5.2 La différenciation (diff).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | function | algebraic | algebraic |
(bvar,algebraic) -> algebraic
(function) -> function
ForAll([x,n],n!=0,diff( x^n , x ) = n*x^(n-1))
diff( sin(x) , x ) = cos(x)
<apply><eq/>
<apply><diff/>
<bvar><ci>x</ci></bvar>
<apply><sin/><ci>x</ci></apply>
</apply>
<apply><cos/><ci>x</ci></apply>
</apply>
diff(x^2,x)
<apply><diff/> <bvar><ci>x</ci></bvar> <apply><power/><ci>x</ci><cn>2</cn></apply> </apply>
diff(f(x),x)
<apply><diff/><bvar><ci> x </ci></bvar> <apply><ci type="function"> f </ci><ci> x </ci></apply> </apply>
diff(sin) = cos
<apply><eq/><apply><diff/><sin/></apply><cos/></apply>
partialdiffCet élément sert à exprimer une différenciation partielle. Il apparaît sous deux formes : l'une correspondant à la différenciation d'expressions algébriques (souvent affichée en employant la notation de Leibnitz) et l'autre pour exprimer les dérivées partielles de fonctions effectives (souvent exprimées selon $D_{1,2} f $)
Pour la première forme, les arguments sont les variables liées, suivies par l'expression algébrique.
Le résultat est une expression algébrique. Les répétitions des variables liées sont indiquées par des éléments degree.
Le degré total est indiqué par un élément degree au niveau supérieur.
Pour la seconde forme, il y a deux arguments : une liste d'indices, indiquant par leur position quelles coordonnées sont impliquées dans la construction des dérivées partielles, et la fonction en question. Les coordonnées peuvent être répétées.
Cf. également la section 4.4.5.3 La différenciation partielle (partialdiff).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
| type | function | algebraic | algebraic |
(degree?,bvar+,algebraic) -> algebraic
(vector,function) -> function
ForAll(x,y,diff( x*y , x ) = diff(x,x)*y + diff(y,x)*x )
ForAll(x,a,b,diff( a + b , x ) = diff(a,x) + diff(b,x) )
diff(sin) = cos
d^k/(dx^m dy^n) f(x,y)
<apply><partialdiff/> <degree><ci>k</ci></degree> <bvar><ci> x </ci><degree><ci> m </ci></degree></bvar> <bvar><ci> y </ci><degree><ci> n </ci></degree></bvar> <apply><ci type="function"> f </ci> <ci> x </ci> <ci> y </ci> </apply> </apply>
d^2/(dx dy) f(x,y)
<apply><partialdiff/> <bvar><ci> x </ci></degree></bvar> <bvar><ci> y </ci></degree></bvar> <apply><ci type="function"> f </ci> <ci> x </ci> <ci> y </ci> </apply> </apply>
D_{1,1,3}(f)
<apply><partialdiff/> <list><cn>1</cn><cn>1</cn><cn>3</cn></list> <ci type="function">f</ci> </apply>
lowlimitCet élément construit une limite inférieure. On utilise des limites supérieures et inférieures dans certaines intégrales comme autre moyen de décrire l'intervalle.
Cf. également la section 4.4.5.4 La limite inférieure (lowlimit).
constructeur
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(algebraic+) -> lowlimit
cf. int
uplimitCet élément construit une limite supérieure. On utilise des limites supérieures et inférieures dans certaines intégrales comme autre moyen de décrire l'intervalle.
Cf. également la section 4.4.5.5 La limite supérieure (uplimit).
constructeur
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(algebraic+) -> uplimit
cf. int
bvarL'élément bvar est l'élément conteneur de la variable liée
d'une opération. Par exemple, dans une intégrale,
il indique la variable d'intégration. Dans une dérivée, il indique la variable par rapport à laquelle la fonction est différenciée.
Lorsque l'élément bvar est utilisé pour quantifier une dérivée, il peut contenir un sous-élément degree
indiquant l'ordre de la dérivée par rapport à cette variable. L'élément bvar sert aussi pour la variable interne
dans les sommes et les produits.
Cf. également la section 4.4.5.6 Les variables liées (bvar).
constructeur
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(symbol,degree?) -> bvar
<apply><forall/><bvar><ci>x</ci></bvar> <condition><apply><in/><ci>x</ci><reals/></apply></condition> <apply><eq/><apply><minus/><ci>x</ci><ci>x</ci></apply><cn>0</cn></apply> </apply>
<apply><diff/> <bvar><ci>x</ci><degree><cn>2</cn></degree></bvar> <apply><power/><ci>x</ci><cn>5</cn></apply> </apply>
degreeUn paramètre utilisé par certains types de données MathML pour indiquer qu'une variable liée est, par exemple, répétée plusieurs fois.
Cf. également la section 4.4.5.7 Le degré (degree).
constructeur
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(anything) -> degree
<apply><diff/> <bvar><ci>x</ci><degree><cn>2</cn></degree></bvar> <apply><power/><ci>x</ci><cn>5</cn></apply> </apply>
divergenceCet élément sert à représenter la fonction de divergence.
Soit un argument qui est un vecteur de fonctions à valeurs scalaires défini sur les coordonnées x_1, x_2, ..., x_n. Il renvoie une fonction de valeur scalaire. Cette fonction satisfait la relation de définition suivante :
divergence(F) = \partial(F_(x_1))/\partial(x_1) + ... + \partial(F_(x_n))/\partial(x_n)
Les fonctions définissant les coordonnées peuvent l'être implicitement comme des expressions définies selon les noms des coordonnées, auquel cas les noms des coordonnées doivent être fournis comme variables liées.
Cf. également la section 4.4.5.8 La divergence (divergence).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(vector(function)) -> function
(bvar+,vector(algebraic)) -> algebraic
<apply><divergence/><ci type="vector"> E</ci></apply>
<declare><ci>F</ci><vector><ci>f1</ci><ci>f2</ci><ci>f3</ci></vector></declare> <apply><divergence/><ci>F</ci></apply>
<apply><divergence/> <bvar><ci>x</ci></bvar><bvar><ci>y</ci></bvar><bvar><ci>z</ci></bvar> <vector> <apply><plus/><ci>x</ci><ci>y</ci></apply> <apply><plus/><ci>x</ci><ci>z</ci></apply> <apply><plus/><ci>z</ci><ci>y</ci></apply> </vector> </apply>
Si a est un champs vectoriel défini dans une surface fermée S englobant un volume V, alors la divergence de a est donnée par :
<apply>
<eq/>
<apply><divergence/><ci type="vectorfield">a</ci></apply>
</apply>
<apply>
<limit/>
<bvar>
<ci> V </ci>
</bvar>
<condition>
<apply>
<tendsto/>
<ci> V </ci>
<cn> 0 </cn>
</apply>
</condition>
<apply>
<divide/>
<apply><int encoding="text" definitionURL="SurfaceIntegrals.htm"/>
<bvar>
<ci> S</ci>
</bvar>
<ci> a </ci>
</apply>
<ci> V </ci>
</apply>
</apply>
</apply>
gradL'élément gradient est l'opérateur de gradient du calcul vectoriel, souvent appelé grad.
Il représente l'opération construisant un vecteur de dérivées partielles vector( df/dx_1, df/dx_2, ..., df/dx_n ).
Cf. également la section 4.4.5.9 Le gradient (grad).
fonction
| Nom | Valeur | Valeur par défaut |
|---|---|---|
| definitionURL | une adresse URI identifiant la définition | APPENDIX_C |
| encoding | CDATA | MathML |
(function) -> vector(function)
(bvar+,algebraic) -> vector(algebraic)
<apply><grad/><ci type="function"> f</ci></apply>
<apply><grad/> <bvar><ci>x</ci></bvar><bvar><ci>y</ci></bvar><bvar><ci>z</ci></bvar> <apply><times/><ci>x</ci><ci>y</ci><ci>z</ci></apply></apply> </apply>
curlCet élément sert à représenter l'opérateur de rotation. Il nécessite à la fois des coordonnées et un vecteur d'expressions définies sur ces coordonnées. Il renvoie une expression à valeur vectorielle.
Dans sa forme fonctionnelle, les coordonnées sont implicites dans la définition de la fonction, de sorte qu'il n'a besoin que d'un seul argument, qui est une fonction à valeur vectorielle, et il renvoie un vecteur de fonctions.
Soit F = F(x,y,z) = ( f1(x,y,z), f2(x,y,z), f3(x,y,z) ) et les noms de coordonnées (x,y,z), la relation suivante doit être vérifiée :
curl(F) = i X \partial(F)/\partial(x) + j X \partial(F)/\partial(y) + j X \partial(F)/\partial(Z),
où i,j,k sont respectivement les vecteurs unitaires correspondant des axes x,y,z
et X est la