Htydjtk

I have defined a command low that adds a subscript to an argument:

newcommand{low}[1]{{#1}_{l_{mathcal{A}}}}

However, if the argument of low contains subscripts itsself (for example in the case of low{low{Sigma}}) it is not easy to see that the subscripts introduced by the outer low belong to the whole argument and not just to the first subscript. Therefore I would like to automatically introduce parentheses if the argument of low contains a subscript (so low{low{Sigma}} should look like low{(low{Sigma})}.

In order to achieve this I tried the following using the xifthen package:

newcommand{low}[1]{ifthenelse{isin{_}{#1}}{{(#1)}_{l_{mathcal{A}}}}{{#1}_{l_{mathcal{A}}}}}

However to my surprise this command only sometimes inserts the parantheses.
In particular it does not do so in the example given above. Why does this happen and what can I do to fix this?

EDIT: It seems that the problem is that isin does not unroll the definitions of commands. @egreg has already provided an answer that allows me to check for nested calls of low but does not work for arguments that contain other commands with subscripts. Does anyone have a solution that works for arbitrary arguments?

You can use a conditional. If it is true, add parentheses, if it is false, set it to true and don't add parentheses.

documentclass{article}

usepackage{amsmath}



newififnestedlow

newcommand{low}[1]{%

  begingroup

  ifnestedlow

    (normallow{#1})%

  else

    nestedlowtrue

    normallow{#1}%

  fi

  endgroup

}

newcommand{normallow}[1]{{#1}_{l_{mathcal{A}}}}



begin{document}



[

low{Sigma} qquad low{low{Sigma}} qquad low{Sigma}

]



end{document}

Doing this in a group ensures the conditional will be false at the next call.

In some cases applying protected@edef and @onelevel@sanitize before checking for a "stringified" _ might work out:

documentclass{article}

usepackage{amsmath}

usepackage{xifthen}



newififnownestlownownestlowfalse



makeatletter

DeclareRobustCommandlow[1]{%

  begingroup

      begingroup

      protected@edef@tempa{#1}%

      @onelevel@sanitize@tempa

      expandafterexpandafterexpandafterendgroup

      expandafterexpandafterexpandafterifthenelse

      expandafterexpandafterexpandafter{%

      expandafterexpandafterexpandafterisin

      expandafterexpandafterexpandafter{%

      expandafterexpandafterstring_%

      expandafter}%

      expandafter{%

      @tempa}}%

      {ifnownestlow(nownestlowfalsenormallow{(#1)})elsenownestlowfalsenormallow{(#1)}fi}%

      {ifnownestlow(nownestlowtruenormallow{#1})elsenownestlowtruenormallow{#1}fi}%

  endgroup

}

makeatother

newcommand{normallow}[1]{{#1}_{l_{mathcal{A}}}}



begin{document}



[

low{Sigma} qquad 

low{low{Sigma}} qquad

low{low{low{Sigma}}} qquad

]

[

low{Sigma_b} qquad 

low{low{Sigma_b}} qquad

low{low{low{Sigma_b}}} qquad

]

[

low{{Sigma_b}} qquad

low{b_{low{c_{low{Sigma_d}}}}} qquad

(Sigma_b)_{l_mathcal{A}}

]



end{document}

expandafter causes that the next but one token —if expandable—gets expanded exactly once before the next token gets expanded if expandable. (La)TeX considers the work of expandafter done when expansion of the next but one token is done. Therefore you can use chains/dequences of expandafter to have (La)TeX "jump" over k tokens for first expanding the (k+1)-th token.

@onelevel@sanitizemacro changes the definition of macro so that macro spits out a sequence of character tokens of category code 12(other) that looks like the token-sequence that would have been "spit out" by macro before applying @onelevel@sanitize. It is almost like redefining macro to what you get by applying string to each token of macro's definition.

protected@edef defines a macro but before doing so, it expands all expandable tokens of the definition-text except those that either are defined via DeclareRobustCommand or are preceded by the token protect. You might say: protected@edef does "unroll" the definitions of the tokens contained in its definition-text before actually performing the assignment.

@tempa is a scratch-macro which gets defined by means of protected@edef to expand to the argument #1 with all definitions in #1 "unrolled".

The ifthenelse{isin...}-test does not find _ that are nested in curly-braces as curly braces usually have a special function. Therefore @onelevel@sanitize is applied for turning all tokens, and thus also the curly braces, into ordinary harmless character-tokens of category code 12(other) which do not disturb the ifthenelse{isin...} test.

An idea (not straight forward solution) is to place the argument inside a box and check its height with the height of a character you suppose is not too tall to need parenthesis but not too short to add parenthesis to your Sigma.

And guess what will be our default argument: Sigma... P

The code (containing some tests) is this:

documentclass{article}

defDefLowArg{$Sigma$}

letoldDefLowArgDefLowArg

newsavebox{myAbox}

newsavebox{myBbox}

newcommand{low}[2][DefLowArg]{saveboxmyAbox{vbox{#1}}saveboxmyBbox{vbox{ensuremath{#2}}}

ifdimdimexprhtmyAbox+dpmyAbox<dimexprhtmyBbox+dpmyBboxrelax

left({#2}right)_{l_{mathcal{A}}}

else {#2}_{l_{mathcal{A}}}fi

}

begin{document}



[low{low{Sigma}}]



[low{Sigma}]

[

low{sum_{i=3}^5 F(x)}

]



[

low{frac{F(x)}{x+5}}

]



[low{F_x}]



[low[1/4]{F(x)}]



[low{x^2}]



[

low{G_x}

]



These commands may be should add without parentheses



[

low{g(z)}

]

[

low{F(x)}

]



{bfseries Solution 1 Add an tall optional argument in the command like: verb|low[/]{F(x)}|}



[

low[/]{g(z)}

]

[

low[/]{F(x)}

]



{bfseries Solution 2 Change the Default argument verb|DefLowArg| to something tall enough (return with verb|letDefLowArgoldDefLowArg|):}



xdefDefLowArg{/}



[

low{g(z)}

]

[

low{F(x)}

]

letDefLowArgoldDefLowArg





{bfseries And back to default}



[

low{F(X)}

]



end{document}

That produces:

PS:Of course manual solutions should be added in special cases but anyway in your command I am sure you would have exceptions for many cases.