Ich arbeite mit der Community zusammen, um Erkenntnisse und mögliche Lösungen für eine LaTeX-Makroanpassung zu finden. Dies ist inspiriert durch eine Diskussion in diesemFaden, das die Möglichkeit untersucht, Token dynamisch durch Steuersequenzen zu ersetzen. Insbesondere die zweite Antwort im Thread bietet eine Grundlage für meinen aktuellen Ansatz, der darauf abzielt, beliebige Symbole oder Wörter mithilfe des Befehls durch angegebene Steuersequenzen zu ersetzen \myspecdef somethinghere : \somecontrolseq.
Hier ist der Codeauszug aus der zweiten Antwort des oben genannten Threads, der den ersten Versuch zur Erstellung dieser Funktionalität demonstriert:
\long\def\isnextchar#1#2#3{\begingroup\toks0={\endgroup#2}\toks1={\endgroup#3}%
\let\tmp=#1\futurelet\next\isnextcharA
}
\def\isnextcharA{\the\toks\ifx\tmp\next0\else1\fi\space}
\def\skipnext#1#2{#1}
\def\trynext#1{\trynextA#1\relax\relax}
\def\trynextA#1#2\relax#3\relax#4#5{%
\ifx\relax#2\relax \def\next{\isnextchar#1{\skipnext{#4}}{#5#3}}\else
\def\next{\isnextchar#1{\skipnext{\trynextA#2\relax#3#1\relax#4{#5}}}{#5#3}}\fi
\next
}
\def\mspecdefA#1#2#3 : #4{\ifx#2\undefined
\def#2{\trynext{#3}#4{#1}}\else
\toks0={\trynext{#3}#4}\toks1=\expandafter{#2}%
\edef#2{\the\toks0{\the\toks1}}\fi
}
\def\mspecdef#1{%
\expandafter\ifx\csname m:#1\endcsname\relax
\expandafter\mathchardef\csname m:#1\endcsname=\mathcode`#1
\fi
\mathcode`#1="8000
\begingroup \lccode`~=`#1
\lowercase{\endgroup\expandafter\mspecdefA\csname m:#1\endcsname~}%
}
\mspecdef << : \ll
\mspecdef <> : \neq
\mspecdef <= : \leq
\mspecdef <== : \Leftarrow
\mspecdef <=> : \Leftrightarrow
\mspecdef <-- : \leftarrow
\mspecdef <-> : \leftrightarrow
\mspecdef >> : \gg
\mspecdef >= : \geq
\mspecdef --> : \rightarrow
\mspecdef -+ : \pm
\mspecdef +- : \mp
\mspecdef ... : \dots
\mspecdef == : \equiv
\mspecdef =. : \doteq
\mspecdef ==> : \Rightarrow
\mspecdef =( : \subseteq
\mspecdef =) : \supseteq
\mspecdef =[ : \sqsubseteq
\mspecdef =] : \sqsubseteq
\myspecdef integration : \int %<- an example of what I want
\myspecdef int : \int %<- this produces an error whilst...
\myspecdef int : \sin %<- does not!
test:
$$ a << b < c <= d >= e > f >> g $$
$$ a <> b = c =. d == e $$
$$ a <== b <-- c <-> d <=> e --> f ==> g $$
$$ a +- b = -(-a -+ +b) $$
$$ a, ..., z <> a + ...+ z $$
$$ a =( b =) c =[ e =] f $$
\[ x^+ \] %<- this produces an error
Obwohl diese Methode dynamische Ersetzungen, wie die Umwandlung integralin , zulässt, bringt sie mehrere Probleme mit sich. Insbesondere verursacht der Befehl bei bestimmten Eingaben, wie beim Definieren von , \intunerwartete Klammerfehler . Obwohl eine alternative Notation dieses Problem löst, ist dies keine ideale Voraussetzung. Darüber hinaus beeinträchtigt die Ersetzung unbeabsichtigt die Funktionalität des Tilde-Zeichens ~, was zu Fehlern wie „fehlende Zahl, wird als Null behandelt“ führt. Darüber hinaus führt die Verwendung von Befehlen wie zu Fehlern aufgrund der Einbeziehung von in die Definition.\[0^+\]\myspecdef +- : \pm\[0^{+}\]\operatorname'bad mathchar'-
Um diese Probleme zu beheben und das Verhalten des Befehls zu verfeinern, bietet die vierte Antwort des Threads einen alternativen Ansatz mit der expl3-Syntax, wie unten dargestellt:
\documentclass{article}
\usepackage{amsmath}
\usepackage{xparse}
\ExplSyntaxOn
\seq_new:N \l_math_subs_seq
\cs_new_protected:Npn \math_add_sub:nn #1 #2
{
\seq_put_right:Nn \l_math_subs_seq { { #1 } { #2 } }
}
\cs_new_protected:Npn \math_ascii_sub:n #1
{
\tl_set:Nn \l_tmpa_tl { #1 }
\seq_map_inline:Nn \l_math_subs_seq
{
\tl_replace_all:Nnn \l_tmpa_tl ##1
}
\tl_use:N \l_tmpa_tl
}
\cs_new_protected:Npn \math_grabinline:w #1 $
{
\math_ascii_sub:n { #1 } $
}
\cs_new_protected:Npn \math_grabdisplay:w #1 \]
{
\math_ascii_sub:n { #1 } \]
}
% Set substitutions (be careful with order!)
% Three letter sequences first
\math_add_sub:nn { <== } { \Leftarrow }
\math_add_sub:nn { <=> } { \Leftrightarrow }
\math_add_sub:nn { <-- } { \leftarrow }
\math_add_sub:nn { <-> } { \leftrightarrow }
\math_add_sub:nn { --> } { \rightarrow }
\math_add_sub:nn { ==> } { \Rightarrow }
\math_add_sub:nn { ... } { \dots }
% Then two letter sequences
\math_add_sub:nn { << } { \ll }
\math_add_sub:nn { <> } { \neq }
\math_add_sub:nn { <= } { \leq }
\math_add_sub:nn { >> } { \gg }
\math_add_sub:nn { >= } { \geq }
\math_add_sub:nn { -+ } { \mp }
\math_add_sub:nn { +- } { \pm }
\math_add_sub:nn { == } { \equiv }
\math_add_sub:nn { =. } { \doteq }
\math_add_sub:nn { =( } { \subseteq }
\math_add_sub:nn { =) } { \supseteq }
\math_add_sub:nn { =[ } { \sqsubseteq }
\math_add_sub:nn { =] } { \sqsubseteq }
% Enable substitutions for $...$ and \[...\]
\everymath { \math_grabinline:w }
\tl_put_right:Nn \[ { \math_grabdisplay:w }
\ExplSyntaxOff
\begin{document}
\centering
\newcommand*{\test}[1]{%
$#1$%
\[#1\]%
}
\test{a << b < c <= d >= e > f >> g}
\test{a <> b = c =. d == e}
\test{a <== b <-- c <-> d <=> e --> f ==> g}
\test{a +- b = -(-a -+ +b)}
\test{a, ..., z <> a + ...+ z}
\test{a =( b =) c =[ e =] f}
\end{document}
Diese Methode scheint zwar vielversprechend und löst einige der Probleme des ursprünglichen Ansatzes, hat aber auch ihre eigenen Einschränkungen. Insbesondere die Reihenfolge der Ersetzungen beeinflusst das Ergebnis erheblich, was die Lösung weniger flexibel und bei umfangreicher Verwendung umständlicher macht. Darüber hinaus habe ich versucht, einen Alias für zu erstellen \spec_add_sub:nn using \cs_new_eq:NN \mspecdef \spec_add_sub:nn, aber außerhalb von hat es nicht die erwartete Leistung erbracht \ExplSyntaxOn ... \ExplSyntaxOff.
Mein Ziel ist es, diese LaTeX-Anpassung zu verfeinern, um ein robusteres und flexibleres Befehlsersetzungssystem zu schaffen, das idealerweise bequem in der Dokumentumgebung verwendet werden kann, da der Präambelzugriff möglicherweise nicht immer verfügbar ist. Ich verstehe, dass dies eine anspruchsvolle oder unkonventionelle Anfrage sein kann, aber ich glaube, dass es ein faszinierendes Problem für die LaTeX-Community darstellt.
Ich freue mich über alle Erkenntnisse, Vorschläge oder alternativen Ansätze, die zu einer verbesserten Lösung führen könnten. Vielen Dank im Voraus für Ihre Zeit und Unterstützung.
Antwort1
Ich habe den in Ihrer Frage bereitgestellten LaTeX3-Code verbessert und er behebt jetzt zwei der Probleme, mit denen Sie konfrontiert waren.
Es erlaubt eine beliebige Substitutionsreihenfolge
Dies wird durch die Pflege eines Präfixbaums für die Symbole in LaTeX ermöglicht. Die gewünschte Substitutionstabelle kann durch die Post-Order-Traversierung des Präfixbaums abgerufen werden. Aus diesem Grund muss der Benutzer jedoch jedes Mal, wenn ein neues Symbol eingefügt wird, aufrufen,
\math_sub_generate:um den Präfixbaum in eine Substitutionstabelle umzuwandeln (natürlich\math_add_sub:nnkann er jederzeit aufrufen\math_sub_generate:).Es unterstützt Alias
Das inkonsistente Verhalten ist wahrscheinlich auf Kategoriecodeunterschiede zwischen Dokumentmodus und LaTeX3-Modus zurückzuführen. Dies kann mit korrigiert werden
\tl_set_rescan:Nnn.
Beachten Sie, dass ich im Code die Reihenfolge der 2-stelligen und 3-stelligen Symbole vertauscht habe. Die Ergebnisse sollten dennoch korrekt sein.
Die endgültige Substitutionstabelle wird wie folgt angezeigt:
The sequence \l_math_subs_seq contains the items (without outer braces):
> {{<<}{\ll }}
> {{<>}{\neq }}
> {{<==}{\Leftarrow }}
> {{<=>}{\Leftrightarrow }}
> {{<=}{\leq }}
> {{<--}{\leftarrow }}
> {{<->}{\leftrightarrow }}
> {{>>}{\gg }}
> {{>=}{\geq }}
> {{-+}{\mp }}
> {{-->}{\rightarrow }}
> {{+-}{\pm }}
> {{==>}{\Rightarrow }}
> {{==}{\equiv }}
> {{=.}{\doteq }}
> {{=(}{\subseteq }}
> {{=)}{\supseteq }}
> {{=[}{\sqsubseteq }}
> {{=]}{\sqsubseteq }}
> {{...}{\dots }}
> {{@@@@@}{\mbox { }FIVE\mbox { }}}
> {{@@@@}{\mbox { }FOUR\mbox { }}}
> {{@@@}{\mbox { }THREE\mbox { }}}.
Code
\documentclass{article}
\usepackage{amsmath}
\usepackage{xparse}
\ExplSyntaxOn
\seq_new:N \l_math_subs_seq
\msg_new:nnn {math} {symbol-exists} {symbol~#1~already~exists}
\int_new:N \g_math_struct_counter
\int_gset:Nn \g_math_struct_counter {1}
\cs_new_protected:Npn \mathstruct_new:N #1
{
\tl_set:Nx #1 {l_mathstruct_internal_\int_use:N \g_math_struct_counter _prop}
\prop_new:c {#1}
\int_gincr:N \g_math_struct_counter
\prop_new:c {l_mathstruct_internal_\int_use:N \g_math_struct_counter _prop}
\prop_put:cnn {#1} {value} {}
\prop_put:cnn {#1} {exist} {\c_false_bool}
\prop_put:cnn {#1} {mapping} {}
\prop_put:cnx {#1} {children} {l_mathstruct_internal_\int_use:N \g_math_struct_counter _prop}
\int_gincr:N \g_math_struct_counter
}
\mathstruct_new:N \l_math_prefix_tree_root
\tl_new:N \l_math_children_prop_tl
\tl_new:N \l_math_tmpa_tl
\tl_new:N \l_math_tmpb_tl
\tl_new:N \l_math_tmpc_tl
\cs_new_protected:Npn \math__recursive_add_sub:nnnn #1#2#3#4
{
\str_if_empty:nTF {#2}
{
\prop_get:cnN {#1} {exist} \l_math_tmpa_tl
\exp_args:NV \bool_if:nTF {\l_math_tmpa_tl}
{
% if symbol alreasy exists, send a warning
\msg_warning:nnn {math} {symbol-exists} {#4}
}
{
% need to set this symbol as "exists" and set the mapping
\prop_put:cnn {#1} {exist} {\c_true_bool}
\prop_put:cnn {#1} {mapping} {#3}
}
}
{
\prop_get:cnN {#1} {children} \l_math_children_prop_tl
\str_set:Nx \l_math_tmpa_tl {\str_head:n {#2}}
% see if it is one of its children
\prop_if_in:cVTF {\l_math_children_prop_tl} \l_math_tmpa_tl
{
% if the node exists, continue recursively
\tl_set:Nx \l_math_tmpc_tl {\str_tail:n {#2}}
\prop_get:cVN {\l_math_children_prop_tl} \l_math_tmpa_tl \l_math_tmpb_tl
\math__recursive_add_sub:Vxnn \l_math_tmpb_tl {\str_tail:n {#2}} {#3} {#4}
}
{
% otherwise, need to create new node
\mathstruct_new:N \l_math_tmpb_tl
\prop_put:cnV {\l_math_tmpb_tl} {value} \l_math_tmpa_tl
\prop_put:cVV {\l_math_children_prop_tl} \l_math_tmpa_tl \l_math_tmpb_tl
% apply recursively
\math__recursive_add_sub:Vxnn \l_math_tmpb_tl {\str_tail:n {#2}} {#3} {#4}
}
}
}
\cs_generate_variant:Nn \math__recursive_add_sub:nnnn {Vxnn,VVVV}
\tl_new:N \l_math_add_tmpa_tl
\tl_new:N \l_math_add_tmpb_tl
\cs_new_protected:Npn \math_add_sub:nn #1 #2
{
\tl_set_rescan:Nnn \l_math_add_tmpa_tl {\cctab_select:N\c_code_cctab} {#1}
\tl_set_rescan:Nnn \l_math_add_tmpb_tl {\cctab_select:N\c_code_cctab} {#2}
\math__recursive_add_sub:VVVV \l_math_prefix_tree_root \l_math_add_tmpa_tl \l_math_add_tmpb_tl \l_math_add_tmpa_tl
}
% post order traversal
\cs_new_protected:Npn \math__sub_recursive_generate:nn #1#2
{
\group_begin:
% check children first
\prop_get:cnN {#1} {children} \l_math_children_prop_tl
\prop_map_inline:cn {\l_math_children_prop_tl}
{
\math__sub_recursive_generate:nn {##2} {#2##1}
}
% check current node
\prop_get:cnN {#1} {exist} \l_math_tmpa_tl
\bool_if:nT {\l_math_tmpa_tl}
{
\prop_get:cnN {#1} {mapping} \l_math_tmpb_tl
\tl_set_rescan:Nnn \l_math_tmpc_tl { \cctab_select:N \c_document_cctab } {#2}
\seq_gput_right:Nx \l_math_subs_seq { {\exp_not:V \l_math_tmpc_tl} {\exp_not:V \l_math_tmpb_tl} }
}
\group_end:
}
% traverse the tree to get the correct order
\cs_new_protected:Npn \math_sub_generate:
{
\seq_gclear:N \l_math_subs_seq
\exp_args:NV \math__sub_recursive_generate:nn \l_math_prefix_tree_root {}
}
\cs_new_protected:Npn \math_ascii_sub:n #1
{
\tl_set:Nn \l_tmpa_tl { #1 }
\seq_map_inline:Nn \l_math_subs_seq
{
\tl_replace_all:Nnn \l_tmpa_tl ##1
}
\tl_use:N \l_tmpa_tl
}
\cs_new_protected:Npn \math_grabinline:w #1 $
{
\math_ascii_sub:n { #1 } $
}
\cs_new_protected:Npn \math_grabdisplay:w #1 \]
{
\math_ascii_sub:n { #1 } \]
}
\cs_set_eq:NN \MathAddSub \math_add_sub:nn
\cs_set_eq:NN \MathGenSub \math_sub_generate:
% Enable substitutions for $...$ and \[...\]
\everymath { \math_grabinline:w }
\tl_put_right:Nn \[ { \math_grabdisplay:w }
\ExplSyntaxOff
\begin{document}
\centering
\newcommand*{\test}[1]{%
$#1$%
\[#1\]%
}
\MathAddSub{ << }{ \ll }
\MathAddSub{ <> }{ \neq }
\MathAddSub{ <= }{ \leq }
\MathAddSub{ >> }{ \gg }
\MathAddSub{ >= }{ \geq }
\MathAddSub{ -+ }{ \mp }
\MathAddSub{ +- }{ \pm }
\MathAddSub{ == }{ \equiv }
\MathAddSub{ =. }{ \doteq }
\MathAddSub{ =( }{ \subseteq }
\MathAddSub{ =) }{ \supseteq }
\MathAddSub{ =[ }{ \sqsubseteq }
\MathAddSub{ =] }{ \sqsubseteq }
\MathAddSub{ <== }{ \Leftarrow }
\MathAddSub{ <=> }{ \Leftrightarrow }
\MathAddSub{ <-- }{ \leftarrow }
\MathAddSub{ <-> }{ \leftrightarrow }
\MathAddSub{ --> }{ \rightarrow }
\MathAddSub{ ==> }{ \Rightarrow }
\MathAddSub{ ... }{ \dots }
\MathAddSub{ int }{ \int }
% generate the substitution table based on post-order traversal of the prefix tree
\MathGenSub
\ExplSyntaxOn
% show the substitution table
\seq_show:N \l_math_subs_seq
\ExplSyntaxOff
\test{a << b < c <= d >= e > f >> g}
\test{a <> b = c =. d == e}
\test{a <== b <-- c <-> d <=> e --> f ==> g}
\test{a +- b = -(-a -+ +b)}
\test{a, ..., z <> a + ...+ z}
\test{a =( b =) c =[ e =] f}
\test{int _a^b}
\test{@@@@@ @@@@ @@@}
\MathAddSub{ @@@ }{ \mbox{~}THREE\mbox{~} }
\MathAddSub{ @@@@ }{ \mbox{~}FOUR\mbox{~} }
\MathAddSub{ @@@@@ }{ \mbox{~}FIVE\mbox{~} }
% generate the substitution table again
\MathGenSub
\ExplSyntaxOn
% show the substitution table
\seq_show:N \l_math_subs_seq
\ExplSyntaxOff
\test{@@@@@ @@@@ @@@}
\end{document}