% arara: lualatex
% arara: lualatex
% arara: clean: { extensions: [ aux, out, log, glo, hd, idx, toc ] }

\documentclass{l3doc}

\usepackage{fontspec}
\usepackage{unicode-math}

\setmainfont{ChronicleTextG3}[
  Extension         = .otf,
  UprightFont       = *-Roman-Pro,
  ItalicFont        = *-Italic-Pro,
  BoldFont          = *-Bold-Pro,
  BoldItalicFont    = *-BoldIta-Pro,
]

\setsansfont{Whitney}[
  Extension   = .otf,
  UprightFont = *-Medium,
  ItalicFont  = *-MediumItalic,
  BoldFont    = *-Bold,
  BoldItalic  = *-BoldItalic
]

\newfontface{\smbold}{Whitney-Semibold.otf}

\setmathfont{NewCMMath-Regular.otf}

\usepackage{source/intexgral}

\NewDifferential{\feynmandiff}{\mathcal{D}}
\RenewDifferential{\odif}{\symup{d}}
\usepackage{codehigh}
\usepackage{booktabs}
\usepackage{microtype}
\usepackage[a]{esvect}
\usepackage{polyglossia}
\setmainlanguage{french}

\usepackage{xcolor}
\definecolor{RoyalBlue}{RGB}{0, 35, 102}
\definecolor{RoyalRed}{RGB}{157, 16, 45}

\usepackage{titlesec}
\titleformat*{\section}{\sffamily\LARGE\bfseries}
\titleformat*{\subsection}{\sffamily\Large\bfseries}
\titleformat*{\subsubsection}{\smbold\large}

\setlength{\parindent}{0pt}
\usepackage{hyperref}
\hypersetup{
  pdfauthor   = {Valentin Dao},
  pdftitle    = {L'extension intexgral},
  pdfcreator  = {LuaLaTeX with hyperref package},
  linkcolor   = RoyalBlue,
  urlcolor    = RoyalRed
}

\NewDocumentCommand{\sarg}{}{*}

\begin{document}

\GetFileInfo{intexgral.sty}

\title{%
  L'extension \pkg{intexgral}%
  \thanks{Ce fichier décrit la version \fileversion, publiée le \filedate}%
}

\author{%
  Valentin Dao%
  \thanks{E-mail: \href{mailto:vdao.texdev@gmail.com}{vdao.texdev@gmail.com}}
}

\date{Publié \filedate}

\maketitle

\begin{documentation}

\begin{abstract}

Tandis que la composition d'intégrales est très fréquent en \LaTeX, cette dernière se révèle souvent peu pratique. Lorsque l'expression devient complexe, il devient alors difficile d'en modifier les différents éléments dans un code source peu lisible. Pour répondre à ce problème, le package \pkg{intexgral} met à disposition une macro centrale dont le seul argument est l'intégrande. Tout le reste (les bornes, les différentielles\dots) pourra aisément être modifié grâce à une interface \meta{clés = valeur}. Contrairement à la méthode classique, où l'utilisateur choisit l'ordre des bornes avec les charactères actifs \verb|_| et \verb|^|, le package a dû fixer une convention. Ainsi, pour les deux clés gérant les bornes qui seront présentées, l'entrée supposée sera \verb|_|\meta{borne inférieure}\verb|^|\meta{borne supérieure}. Ce package étant écrit en \pkg{expl3}, il dépend donc des packages \LaTeX3 \pkg{l3kernel} et \pkg{l3package}. De plus, \pkg{intexgral} utilise le package \pkg{derivative} afin de faciliter la manipulation de différentielles.

\end{abstract}

\tableofcontents

\section{Options de package}

Ces options peuvent être utilisées avec la syntaxe suivante lorsque le package est chargé dans le préambule:

\begin{center}
  \ttfamily
  \cs{usepackage}\oarg{clés}\{intexgral\}
\end{center}

\begin{variable}{invert-limits}
  \begin{syntax}
    \meta{boolean}\hfill(défaut: false)
  \end{syntax}
  Cette clé permet d'inverser la convention d'ordre des limites. L'entièreté du document ne peut suivre qu'une seule convention.
\end{variable}

\begin{function}{invert-differentials}
  \begin{syntax}
    \meta{boolean}\hfill(défaut: false)
  \end{syntax}
  Il est courrant de voir les différentielles placées avant l'intégrande dans les articles de physique. Cette clé intervertit donc leurs positionnements.
\end{function}

\begin{function}{hide-differentials}
  \begin{syntax}
    \meta{boolean}\hfill(défaut: false)
  \end{syntax}
  Si l'utilisateur souhaite que les différentielles ne soient pas affichées tout au long du document, cette clé désactive complètement la composition automatique de celles-ci. 
\end{function}

\begin{function}{italic, upright}
  \begin{syntax}
    \meta{boolean}\hfill(défaut: false)
    \meta{boolean}\hfill(défaut: true)
  \end{syntax}
  Ce sont les deux clés du package \pkg{derivative}.  
\end{function}

\section{Présentation de la macro principale}

\begin{function}{\integral}
  \begin{syntax}
    \oarg{liste de clés}\marg{intégrande}
  \end{syntax}
  Cette macro est celle qui permet de composer les intégrales. Elle doit naturellement être utilisée en mode mathématique. En voici un premier exemple:
\end{function}

\begin{codehigh}
\integral{f(x)}
\end{codehigh}

\begin{equation}
  \integral{f(x)}
\end{equation}

Puisque cette macro est axée autour de l'utilisation de clés, la première partie de cette documentation les présentera en les regroupant par domaines. La seconde partie quant à elle documentera les macros auxiliaires qui viennent compléter les fonctionnalités de certaines clés.

\section{Liste des clés}

\subsection{Bornes d'intégration}

\subsubsection{Définir les bornes}

\begin{function}{limits, limits*}
  \begin{syntax}
    \marg{pseudo-clist}, \meta{mot-clé}
    \marg{pseudo-clist}, \meta{mot-clé}
  \end{syntax}
  Cette clé détermine les bornes d'intégration à utiliser en suivant la convention édictée dans le résumé. 
\end{function}

\begin{codehigh}
  \integral[
    limits={1, 10}
    ]{f(x)}
\end{codehigh}

\begin{equation}
\integral[
  limits={1, 10}
  ]{f(x)}
\end{equation}

La version étoilée de la clé exprime les bornes sous la forme d'un intervalle. Le sens des crochets s'adapte automatiquement à la présence de $\pm$\cs{infty}.

\begin{codehigh}
\integral[
  limits*={1, 10},
  ]{f(x)}
\end{codehigh}

\begin{equation}
\integral[
  limits*={1, 10},
  ]{f(x)}
\end{equation}

La grande force de \texttt{limits} est qu'elle permet de spécifier les bornes de plusieurs intégrales et se charge de les composer pour vous. Pour ce faire, il faut séparer les bornes de point-virgules pour permettre au package de correctement évaluer à quelle intégrale elles appartiennent.

\begin{codehigh}
\integral[
  limits={0, R; 0, H; 0, 2\pi},
  variable={\rho, z, \phi}
  ]{\rho z \phi}
\end{codehigh}

\begin{equation}
\integral[
  limits={0, R; 0, H; 0, 2\pi},
  variable={\rho, z, \phi}
  ]{\rho z \phi}
\end{equation}

\subsubsection{Séparer l'intégrale}

\begin{function}{int-split}
  \begin{syntax}
    \meta{boolean}\hfill(défaut: false)
  \end{syntax}
  Cette clé sépare les différentes variables de l'intégrales et les isole. Il est donc nécessaire de l'utiliser \emph{avant} \texttt{limits} afin que celle ci sache dans quel mode opérer. De plus, cette clé requiert que l'on indique comment séparer l'intégrande. Cette étape supplémentaire se réalise en suivant la même logique que pour les bornes, c'est-à-dire en utilisant le point-virgule. 
\end{function}

\begin{codehigh}
\integral[
  int-split=true,
  limits={radius; height; circle},
  variable={\rho, z, \phi}
  ]{\rho; z; \phi}
\end{codehigh}

\begin{equation}
\integral[
  int-split=true,
  limits={radius; height; circle},
  variable={\rho, z, \phi}
  ]{\rho; z; \phi}
\end{equation}

Pour bien fonctionner, il est évident que les clés \texttt{limits} et \texttt{variable}\footnote{à découvrir d'ici peu.}, ainsi que l'intégrande, doivent avoir la même dimension. Si ce n'est pas le cas, la compilation n'échouera pas, mais l'expression de l'intégrale risque de ne plus avoir aucun sens. De nombreux messages d'avertissement seront là pour vous en informer et vous dire ce qui ne va pas. N'oubliez donc pas les virgules et/ou point-virgules même si un élément reste vide!

\subsubsection{Choisir le positionnement des bornes}

\begin{function}{limits-mode}
  \begin{syntax}
    limits, nolimits\hfill(défaut: nolimits)
  \end{syntax}
  Équivalent à employer \cs{limits} ou \cs{nolimits}.
\end{function}

\begin{codehigh}
\integral[
  limits-mode=limits,
  limits={a, b}
  ]{f(x)}
\end{codehigh}

\begin{equation}
  \integral[
    limits-mode=limits,
    limits={a, b}
    ]{f(x)}
\end{equation}

\subsection{Symbole (et encore des bornes)}

Les clés \texttt{limits} et \texttt{limits*} se révèlent très utiles lorsque l'expression finale d'une intégrale est déterminée (autrement dit, lorsque les bornes de chaque variable ont été définies). Cependant, cela couvre seulement\dots\ l'expression finale! Pour des cas plus généraux, elles sont relativement malcommodes. Pour composer une intégrale double sur une surface S, on devrait écrire \verb|limits={,;,S}|. Il va sans dire que c'est assez maladapté pour l'utilisateur et peu optimal pour le package. Par ailleurs, le glyphe ne serait pas correct. L'ensemble des clés à suivre propose donc une façon de modifier facilement le symbole intégrale et les bornes.

\subsubsection{Séléctionner le symbole}

\begin{function}{int-symb}
  \begin{syntax}
    \meta{séquence de contrôle}
  \end{syntax}
  Cette clé accepte une macro désignant un symbole intégrale. Par exemple, \verb|int-symb=\oint| revient à utiliser \verb|\oint_{...}^{...}|. Par défaut, le package \pkg{intexgral} tente de charger tous les symboles d'\pkg{unicode-math}\footnotemark, étant donné qu'il en offre le plus grand nombre. Si un symbole n'est pas défini, un message d'avertissement sera émis et la commande manquante sera substituée à \cs{int}.
\end{function}
\footnotetext{Voir la documentation pour la \href{https://ctan.mines-albi.fr/macros/unicodetex/latex/unicode-math/unimath-symbols.pdf}{liste complète} des symboles.}

\begin{codehigh}
\integral[
  int-symb=\oint,
  lower-lim=\mathcal{C},
  diff-vec=true,
  ]{f(\vec{r})}
\end{codehigh}

\begin{equation}
  \integral[
    int-symb=\oint,
    lower-lim=\mathcal{C},
    diff-vec=true,
    ]{f(\vec{r})}
\end{equation}

\subsubsection{Générer beaucoup intégrales}

\begin{function}{nint}
  \begin{syntax}
    \meta{entier}
  \end{syntax}
  Cette clé accepte un entier $n$ qui permet de composer $n$ intégrales. Il est conseillé d'avoir recours à cette clé seulement si le nombre de symboles dépasse 4.
\end{function}

\begin{codehigh}
\integral[
  nint=5,
  lower-lim=\Omega,
  variable={x_1, x_2, x_3, x_4, x_5}
  ]{f(x_1, x_2, x_3, x_4, x_5)}
\end{codehigh}

\begin{equation}
  \integral[
    nint=5,
    lower-lim=\Omega,
    variable={x_1, x_2, x_3, x_4, x_5}
    ]{f(x_1, x_2, x_3, x_4, x_5)}
\end{equation}

\subsubsection{Définir les bornes (lorsqu'il n'y a qu'un seul symbole)}

\begin{function}{lower-lim, upper-lim}
  \begin{syntax}
    \marg{borne inférieure}
    \marg{borne supérieure}
  \end{syntax}
  Ces deux clés permettent de spécifier la bornes inférieure et supérieure respectivement. Si vous avez besoin de renseigner les deux bornes, la clé \texttt{limits} devrait être utilisée.
\end{function}

\begin{codehigh}
\integral[
  lower-lim={x^2 + y^2 \leq 1},
  variable={x, y}
  ]{f(x, y)}
\end{codehigh}

\begin{equation}
  \integral[
    lower-lim={x^2 + y^2 \leq 1},
    variable={x, y}
    ]{f(x, y)}
\end{equation}

\vspace{\baselineskip}

Les clés précedentes (sans compter \texttt{nint}) couvrent un usage --- je l'espère --- assez général. Toutefois, on peut optimiser d'avantage pour un gain de temps supplémentaire. C'est pourquoi en plus de \texttt{int-symb}, \texttt{lower-lim} et \texttt{upper-lim}, \pkg{intexgral} propose des clés \emph{raccourci}:

\subsubsection{Combiner symbole et borne}

\begin{function}{single, double, triple, quadruple, contour, surface, volume}
  \begin{syntax}
    \marg{borne inférieure}\hfill(symbole: \cs{int})
    \marg{borne inférieure}\hfill(symbole: \cs{iint})
    \marg{borne inférieure}\hfill(symbole: \cs{iiint})
    \marg{borne inférieure}\hfill(symbole: \cs{iiiint})
    \marg{borne inférieure}\hfill(symbole: \cs{oint})
    \marg{borne inférieure}\hfill(symbole: \cs{oiint})
    \marg{borne inférieure}\hfill(symbole: \cs{oiiint})
  \end{syntax}
  Toutes ces clés permettent de regrouper l'action de \texttt{int-symb} et \texttt{lower-lim} ensemble, facilitant le choix du symbole et de la borne inférieure en même temps. La valeur de la clé est optionnelle, auquel cas le symbole changera mais la borne restera vide.
\end{function}

\begin{codehigh}
\integral[
  double=S,
  variable={x, y}
  ]{xy}
\end{codehigh}

\begin{equation}
  \integral[
    double=S,
    variable={x, y}
    ]{xy}
\end{equation}

\subsubsection{Motifs récurrents de bornes}

Tous comme pour les symboles, les bornes suivent parfois des schémas courants qui peuvent se généraliser avec des clés, évitant de surcharger l'expression de \texttt{lower-lim}.

\begin{function}{domain}
  \begin{syntax}
    \marg{*-list}
  \end{syntax}
  Cette clé accepte une liste dont le délimiteur est un astérisque. Ensuite, chaque élément de la liste est analysée de la façon suivante:
  \begin{itemize}
    \item Le premier token de l'item se voit passer \cs{mathbb} (précédé d'\cs{uppercase} au cas où la touche \textsc{shift} serait trop loin pour vos doigts).
    \item Les tokens restants --- qui peuvent être vides --- sont interprétés comme la puissance cartésienne de l'ensemble. 
  \end{itemize}
\end{function}

\begin{codehigh}
\integral[
  double,
  domain={r*r},
  variable={x, y}
  ]{xy}
\end{codehigh}

\begin{equation}
  \integral[
    double,
    domain={r*r},
    variable={x, y}
    ]{xy}
\end{equation}

\begin{function}{boundary}
  \begin{syntax}
    \marg{borne inférieure}
  \end{syntax}
  Cette clé place simplement le symbol $\partial$ avant la borne inférieure.
\end{function}

\begin{codehigh}
\integral[
  contour,
  variable=r,
  diff-vec=true,
  boundary=S
  ]{G(\vec{r})}
\end{codehigh}

\begin{equation}
  \integral[
    contour,
    variable=r,
    diff-vec=true,
    boundary=S
    ]{G(\vec{r})}
\end{equation}

\subsection{Différentielles}

\subsubsection{Spécifier les variables}

\begin{function}{variable}
  \begin{syntax}
    \marg{clist}, \meta{mot-clé}, none
  \end{syntax}
  Cette clé permet de spécifier les paramètres d'intégration sous forme de liste d'éléments séparés par des virgules (clist). Si cette clé n'est pas renseignée, le package affichera par défaut $\odif{x}$ (ou $\odif{\vec{r}}$ si \texttt{diff-vec} est activé). Si \texttt{none} est passé comme valeur, aucune différentielle ne sera affichée.
\end{function}

\begin{codehigh}
\integral[
  triple=V,
  variable={x, y, z}
  ]{f(x, y, z)}
\end{codehigh}

\begin{equation}
  \integral[
    triple=V,
    variable={x, y, z}
    ]{f(x, y, z)}
\end{equation}

\subsubsection{Inclure le jacobien}

\begin{function}{jacobien}
  \begin{syntax}
    \meta{boolean}\hfill(défaut: false)
  \end{syntax}
  Cette clé active/désactive l'affichage du jacobien lorsque défini par \cs{NewDifferentialKeyword} (voir \ref{subsec:diff})
\end{function}

\begin{codehigh}
V_\textrm{sphère} = 
\integral[
  int-split=true,
  limits={0, R; 0, 2\pi; 0, \pi},
  variable=spherical,
  jacobian=true,
  ]{;;}
\end{codehigh}

\begin{equation}
  V_\textrm{sphère} = 
  \integral[
    int-split=true,
    limits={0, R; 0, 2\pi; 0, \pi},
    variable=spherical,
    jacobian=true,
    ]{;;}
\end{equation}

\subsubsection{Modifier le symbole}

\begin{function}{diff-symb}
  \begin{syntax}
    \meta{séquence de contrôle}
  \end{syntax}
  Comme évoqué plus tôt, le package \pkg{derivative} est utilisé pour la mise en forme des différentielles. Cette clé permet de changer le style des différentielles parmi ceux définis par \cs{NewDifferential}. 
\end{function}

\begin{codehigh}
\NewDifferential{\feynmandiff}{\mathcal{D}}
\integral[
  variable={q(t)},
  diff-symb=\feynmandiff
  ]{e^{+\dfrac{\imath S[q(t)]}{\hbar}}}
\end{codehigh}

\begin{equation}
  \integral[
    variable={q(t)},
    diff-symb=\feynmandiff
    ]{e^{+\dfrac{\imath S[q(t)]}{\hbar}}}
\end{equation}

\subsubsection{Opter pour la variante étoilée}

\begin{function}{diff-star}
  \begin{syntax}
    \meta{boolean}\hfill(défaut: false)
  \end{syntax}
  Si cette clé est vraie, cela revient à utiliser \cs{odif*{}} ou ses variantes.  
\end{function}

\begin{codehigh}
\integral[
  double,
  variable={x, y},
  diff-star=true
  ]{x^2 \exp(y)}
\end{codehigh}

\begin{equation}
  \integral[
    double,
    variable={x, y},
    diff-star=true
    ]{x^2 \exp(y)}
\end{equation}

\subsubsection{Désigner des options}

\begin{function}{diff-options}
  \begin{syntax}
    \marg{clés}
  \end{syntax}
  Cette clé accepte une liste de clés telle qu'elle aurait été écrite comme argument optionnel de \cs{odif} ou ses variantes. Pour illustrer, \verb|diff-options={order={2, 3}, var=all}| sera interprété comme \verb|\odif[order={2, 3}, var=all]{...}|.
\end{function}

\begin{codehigh}
\integral[
  diff-options={order=4}
  ]{\bar{\psi}(x)(\imath\gamma^\mu\partial_\mu-m)\psi(x)}
\end{codehigh}

\begin{equation}
  \integral[
    diff-options={order=4}
    ]{\bar{\psi}(x)(\imath\gamma^\mu\partial_\mu-m)\psi(x)}
\end{equation}

\subsubsection{Réaliser une intégrale curviligne}

\begin{function}{diff-vec}
  \begin{syntax}
    \meta{boolean}
  \end{syntax}
  Cette clé applique \cs{vec} à chaque paramètre d'intégration et place un \cs{cdot} comme séparation.
\end{function}

\begin{codehigh}
\integral[
  double=S,
  variable=S,
  diff-vec=true,
  ]{\vec{F}}
\end{codehigh}

\begin{equation}
  \integral[
    double=S,
    variable=S,
    diff-vec=true,
    ]{\vec{F}}
\end{equation}

\subsubsection{Personnaliser le vecteur}

\begin{function}{diff-vec-style}
  \begin{syntax}
    \meta{séquence de contrôle}
  \end{syntax}
  Il existe de nombreux styles de vecteurs différents en \LaTeX. Ainsi, cette clé utilise la séquence de contrôle donnée comme valeur pour formatter le vecteur. Par exemple, avec le package \pkg{esvect} chargé avec le style \texttt{a}:
\end{function}

\begin{codehigh}
\integral[
  double=S,
  variable=S,
  diff-vec=true,
  diff-vec-style=\vv,
  ]{\vv{S}}
\end{codehigh}

\begin{equation}
  \integral[
    double=S,
    variable=S,
    diff-vec=true,
    diff-vec-style=\vv,
    ]{\vv{S}}
\end{equation}

\section{Macros auxiliaires}

\subsection{Charger des symboles}

\begin{function}{\NewIntegralSymbol}
  \begin{syntax}
    \marg{csname}
  \end{syntax}
  Si vous utilisez un package définissant des symboles ne faisants pas partie d'\pkg{unicode-math}, vous pouvez les charger en utilisant la macro \cs{NewIntegralSymbol} dans le préambule. Il seront dès lors accessible avec la clé \texttt{int-symb}. L'argument devra prendre la forme d'une commande \emph{sans antislash}: par exemple \verb|NewIntegralSymbol{myint}|. Veuillez noter que \cs{NewIntegralSymbol} n'est qu'un moyen pour le package de reconnaître les symboles préexistants et leurs macros de façon interne. Ce n'est en rien une manière de créer un nouveau glyphe. Il en va de la responsabilité de l'utilisateur de charger les packages nécessaires pour que les symboles voulus soient définis.
\end{function}

\subsection{Retour sur les bornes}

\begin{function}{\NewLimitsKeyword, \RenewLimitsKeyword, \ProvideLimitsKeyword, \DeclareLimitsKeyword}
  \begin{syntax}
    \marg{mot-clé}\marg{bornes}
  \end{syntax}
Il est courrant de devoir renseigner les même bornes dans une intégrale. Pour faciliter leur écriture, les clé(s) \texttt{limits(*)} accepte également un mot-clé désignant des bornes définies par l'un de ces quatre macros:
\end{function}
\begin{itemize}
  \item \cs{NewLimitsKeyword} crée un nouveau mot clé et émet une erreur s'il existe déjà.
  \item \cs{RenewLimitsKeyword} redéfinit un mot clé et émet une erreur s'il n'existe pas déjà. 
  \item \cs{ProvideLimitsKeyword} ne crée un nouveau mot clé que s'il n'existe pas déjà. Aucun message ne sera émis dans le cas échéant.
  \item \cs{DeclareLimitsKeyword} crée un nouveau mot clé quoiqu'il en soit, écrasant toute définition préalable.
\end{itemize}

En reprenant l'un des exemples précédents, ont pourrait modifier l'expression de l'intégrale de la façon suivante:

\begin{codehigh}
\integral[
  limits={radius; height; circle},
  variable={\rho, z, \phi}
  ]{\rho z \phi}
\end{codehigh}

\begin{equation}
  \integral[
    limits={radius; height; circle},
    variable={\rho, z, \phi}
    ]{\rho z \phi}
\end{equation}

\begin{table}[h!t]
  \centering
  \begin{tabular}{l c}
    \toprule
    Mot-clé & Bornes\\
    \midrule
    ab & $a, b$\\
    real & $-\infty, +\infty$\\
    positive & $0, +\infty$\\
    negative & $-\infty, 0$\\
    unit & $0, 1$\\
    circle & $0, 2\pi$\\
    scircle & $0, \pi$\\
    qcircle & $0, \frac{pi}{2}$\\
    height & $0, H$\\
    radius & $0, R$\\
    length & $0, L$\\
    time & $0, T$\\
    \bottomrule
  \end{tabular}
  \caption{Liste des mot-clés pour les bornes.}
\end{table}

\textbf{Important:} dû à l'implémentation de \cs{NewLimitsKeyword} et ses variantes, l'utilisateur \emph{doit} suivre la convention d'ordre des bornes du package, même si \texttt{invert-limits} est fixé à \texttt{true}.

\subsection{Retour sur les différentielles}\label{subsec:diff}

\begin{function}{\NewDifferentialKeyword, \RenewDifferentialKeyword, \ProvideDifferentialKeyword, \DeclareDifferentialKeyword}
  \begin{syntax}
    \marg{mot-clé}\marg{différentielles}\oarg{jacobien}
  \end{syntax}
De façon similaire, les mêmes groupes de différentielles réapparaissent souvent. On peut donc également définir des mots clés dont la liste est déjà prédéfinie (les variantes ont le même comportement). 
\end{function}

La seule différence est que l'on peut en plus spécifier un jacobien. Ce dernier devra prendre la forme d'une clist. Ceci permet de pouvoir séparer le jacobien lorsque le mode \texttt{int-split} est activé. Son affichage est contrôlé par la clé \texttt{jacobian} expliquée précedemment.

\begin{codehigh}
\integral[
  triple={V},
  variable=cartesian
  ]{f(x, y, z)}
\end{codehigh}

\begin{equation}
  \integral[
    triple={V},
    variable=cartesian
    ]{f(x, y, z)}
\end{equation}

\begin{table}[hb]
  \centering
  \begin{tabular}{l c c}
    \toprule
    Mot-clé & Différentielles & Jacobien \\
    \midrule
    cartesian & $x, y, z$ & -- \\
    polar & $r, \theta$ & $ r $ \\
    cylindrical & $r, \theta, z$ & $ r $ \\
    spherical & $ r, \theta, \phi $ & $ r, \sin\theta $ \\
    \bottomrule
  \end{tabular}
  \caption{Liste des mot-clés pour les différentielles.}
\end{table}

\subsection{Emplacements personnalisés des différentielles}

\begin{function}{\differentials}
  Bien que l'option \texttt{invert-differentials} existe, il est souvent souhaitable de pouvoir placer les différentielles où l'on veut. Par exemple, il est fréquent de les voir au numérateur d'une fraction lorsque celui ci vaut 1. Pour répondre à ce besoin, le package met à disposition la macro \verb|\differentials|. Lorsque \texttt{int-split=false}, \cs{differentials} compose toutes les differentielles au même endroit. Si \texttt{int-split=true}, il faudra réécrire \cs{differentials} entre chaque point-virgule. Dans les deux cas, le jacobien sera rattaché aux différentielles.
\end{function}

\begin{codehigh}
\integral[
  variable={a},
  ]{\frac{\differentials}{a}} = \ln(a) + C
\end{codehigh}

\begin{equation}
  \integral[
    variable={a},
    ]{\frac{\differentials}{a}} = \ln(a) + C
\end{equation}

\end{documentation}

\end{document}