Logical AND in conditionals with primitives - TeX

TopAnswers TeX

Top Answer

Skillmon

The following is a simple method to get OR, AND, and XOR supported. Anything unequal to zero is interpreted as true, each `\if` returns either 0 (false) or 1 (true), then an AND is a multiplication, an OR is an addition, and a XOR is a subtraction.

This is combined in a `\numexpr` for a single `\ifnum` test (and this way fully expandable, your `\if`-tests must be fully expandable as well here).

I read you prefer without `\expandafter`s, but I included one to get the branching as arguments (`\expandafter` simply expands the `\fi` (expands to nothing, closing the `\ifnum`-block) before the `\@thirdofthree` so that the `\ifnum` is complete (if it was true), and `\@thirdofthree` sees as its arguments `\@firstoftwo{<true>}{<false>}` picking up `<false>`).

The code for AND and OR scale to arbitrary many relations this way, XOR on the other hand doesn't.

```
\documentclass{article}

\newcounter{mycnta}
\newcounter{mycntb}

\makeatletter
\providecommand\@thirdofthree[3]{#3}
\newcommand\checking[1]
  {%
    \ifnum0=\numexpr
        \ifnum\value{mycnta}=1 1\else0\fi
        #1\ifnum\value{mycntb}=14 1\else0\fi
      \relax
      \expandafter\@thirdofthree
    \fi
    \@firstoftwo
  }
\makeatother

\newcommand\checkingAND
  {%
    \checking{*}%
      {true}
      {false}%
  }
\newcommand\checkingOR
  {%
    \checking{+}%
      {true}
      {false}%
  }
\newcommand\checkingXOR
  {%
    \checking{-}%
      {true}
      {false}%
  }

\begin{document}
\begin{enumerate}
\item
  \setcounter{mycnta}{1}
  \setcounter{mycntb}{14}

  AND should return true. Returns \checkingAND.\\
  OR should return true. Returns \checkingOR.\\
  XOR should return false. Returns \checkingXOR.

\item
  \setcounter{mycnta}{3}
  \setcounter{mycntb}{15}

  AND should return false. Returns \checkingAND.\\
  OR should return false. Returns \checkingOR.\\
  XOR should return false. Returns \checkingXOR.

\item
  \setcounter{mycnta}{2}
  \setcounter{mycntb}{14}

  AND should return false. Returns \checkingAND.\\
  OR should return true. Returns \checkingOR.\\
  XOR should return true. Returns \checkingXOR.

\item
  \setcounter{mycnta}{1}
  \setcounter{mycntb}{15}

  AND should return false. Returns \checkingAND.\\
  OR should return true. Returns \checkingOR.\\
  XOR should return true. Returns \checkingXOR.
\end{enumerate}
\end{document}
```

---

Because Joseph kind-of challenged me, the following implements AND, OR, and XOR without using `\numexpr`, unfortunately we need a bit more variety in our `\checking` macro from above, hence the following has a bit more code to achieve the same with a bit better performance. The AND and OR relations are implemented lazy (meaning the second conditional is only evaluated if the result isn't clear after the first).

```
\documentclass{article}

\newcounter{mycnta}
\newcounter{mycntb}

\makeatletter
\providecommand\@thirdofthree[3]{#3}
\newcommand\checkingAND
  {%
    \ifnum\ifnum\value{mycnta}=1 \ifnum\value{mycntb}=14 1\else0\fi\else0\fi=0
      \expandafter\@thirdofthree
    \fi
    \@firstoftwo
    {true}{false}%
  }
\newcommand\checkingOR
  {%
    \ifnum\ifnum\value{mycnta}=1 1\else\ifnum\value{mycntb}=14 1\else0\fi\fi=0
      \expandafter\@thirdofthree
    \fi
    \@firstoftwo
    {true}{false}%
  }
\newcommand\checkingXOR
  {%
    \ifnum\ifnum\value{mycnta}=1 1\else0\fi=\ifnum\value{mycntb}=14 1\else0\fi\space
      \expandafter\@thirdofthree
    \fi
    \@firstoftwo
    {true}{false}%
  }
\makeatother

\begin{document}
\begin{enumerate}
\item
  \setcounter{mycnta}{1}
  \setcounter{mycntb}{14}

  AND should return true. Returns \checkingAND.\\
  OR should return true. Returns \checkingOR.\\
  XOR should return false. Returns \checkingXOR.

\item
  \setcounter{mycnta}{3}
  \setcounter{mycntb}{15}

  AND should return false. Returns \checkingAND.\\
  OR should return false. Returns \checkingOR.\\
  XOR should return false. Returns \checkingXOR.

\item
  \setcounter{mycnta}{2}
  \setcounter{mycntb}{14}

  AND should return false. Returns \checkingAND.\\
  OR should return true. Returns \checkingOR.\\
  XOR should return true. Returns \checkingXOR.

\item
  \setcounter{mycnta}{1}
  \setcounter{mycntb}{15}

  AND should return false. Returns \checkingAND.\\
  OR should return true. Returns \checkingOR.\\
  XOR should return true. Returns \checkingXOR.
\end{enumerate}
\end{document}
```

```

Answer #2

frougon

Not directly using primitives, but I think this may be useful.

Here are two ways with `expl3`. All these macros are expandable.

# Naive way

```
\documentclass{article}

\ExplSyntaxOn

\cs_new:Npn \my_and:nnTF #1#2
  {
    \bool_lazy_and:nnTF         % we didn't grab the T and F args
      { \int_compare_p:nNn { \value{mycnta} } = {#1} }
      { \int_compare_p:nNn { \value{mycntb} } = {#2} }
  }

\cs_new:Npn \my_or:nnTF #1#2
  {
    \bool_lazy_or:nnTF         % we didn't grab the T and F args
      { \int_compare_p:nNn { \value{mycnta} } = {#1} }
      { \int_compare_p:nNn { \value{mycntb} } = {#2} }
  }

\cs_new:Npn \my_xor:nnTF #1#2
  {
    \bool_xor:nnTF             % we didn't grab the T and F args
      { \int_compare_p:nNn { \value{mycnta} } = {#1} }
      { \int_compare_p:nNn { \value{mycntb} } = {#2} }
  }

\cs_new_eq:NN \myAnd \my_and:nnTF
\cs_new_eq:NN \myOr \my_or:nnTF
\cs_new_eq:NN \myXor \my_xor:nnTF

\ExplSyntaxOff

\newcounter{mycnta}
\newcounter{mycntb}

\begin{document}

\setcounter{mycnta}{1}
\setcounter{mycntb}{14}

\noindent
\myAnd{1}{14}{true}{false}\\
\myAnd{2}{14}{true}{false}\\
\myAnd{1}{12}{true}{false}\\
\myAnd{2}{12}{true}{false}

\medskip\noindent
\myOr{1}{14}{true}{false}\\
\myOr{2}{14}{true}{false}\\
\myOr{1}{12}{true}{false}\\
\myOr{2}{12}{true}{false}

\medskip\noindent
\myXor{1}{14}{true}{false}\\
\myXor{2}{14}{true}{false}\\
\myXor{1}{12}{true}{false}\\
\myXor{2}{12}{true}{false}

\end{document}
```

![image.png](/image?hash=5efbb21c3be67f7235eea53f11a73810ec53e65ff4d9dc2ad8902701e991ffe4)

# Better way (more flexible)

This way generates the predicate forms (`\my_and_p:nn`, `\my_or_p:nn` and `\my_xor_p:nn`) as well as all variants:
  - `\my_and:nnT`, `\my_and:nnF` and `\my_and:nnTF`;
  - `\my_or:nnT`, `\my_or:nnF` and `\my_or:nnTF`;
  - `\my_xor:nnT`, `\my_xor:nnF` and `\my_xor:nnTF`.
  
```
\documentclass{article}
\usepackage[table]{xcolor}

\ExplSyntaxOn

\prg_new_conditional:Npnn \my_and:nn #1#2 { p, T, F, TF }
  {
    \bool_lazy_and:nnTF
      { \int_compare_p:nNn { \value{mycnta} } = {#1} }
      { \int_compare_p:nNn { \value{mycntb} } = {#2} }
      { \prg_return_true: }
      { \prg_return_false: }
  }

\prg_new_conditional:Npnn \my_or:nn #1#2 { p, T, F, TF }
  {
    \bool_lazy_or:nnTF
      { \int_compare_p:nNn { \value{mycnta} } = {#1} }
      { \int_compare_p:nNn { \value{mycntb} } = {#2} }
      { \prg_return_true: }
      { \prg_return_false: }
  }

\prg_new_conditional:Npnn \my_xor:nn #1#2 { p, T, F, TF }
  {
    \bool_xor:nnTF
      { \int_compare_p:nNn { \value{mycnta} } = {#1} }
      { \int_compare_p:nNn { \value{mycntb} } = {#2} }
      { \prg_return_true: }
      { \prg_return_false: }
  }

\cs_new_eq:NN \myAndT \my_and:nnT
\cs_new_eq:NN \myAndF \my_and:nnF
\cs_new_eq:NN \myAndTF \my_and:nnTF

\cs_new_eq:NN \myOrTF \my_or:nnTF
\cs_new_eq:NN \myXorTF \my_xor:nnTF

\ExplSyntaxOff

\newcounter{mycnta}
\newcounter{mycntb}

\begin{document}

\setcounter{mycnta}{1}
\setcounter{mycntb}{14}

\noindent
\begin{tabular}{@{} *{3}{l} @{}}
\myAndTF{1}{14}{true}{false} & \myAndT{1}{14}{true} & \myAndF{1}{14}{false}\\
\myAndTF{2}{14}{true}{false} & \myAndT{2}{14}{true} & \myAndF{2}{14}{false}\\
\myAndTF{1}{12}{true}{false} & \myAndT{1}{12}{true} & \myAndF{1}{12}{false}\\
\myAndTF{2}{12}{true}{false} & \myAndT{2}{12}{true} & \myAndF{2}{12}{false}
\end{tabular}

\medskip\noindent
\myOrTF{1}{14}{true}{false}\\
\myOrTF{2}{14}{true}{false}\\
\myOrTF{1}{12}{true}{false}\\
\myOrTF{2}{12}{true}{false}

\medskip\noindent
\myXorTF{1}{14}{true}{false}\\
\myXorTF{2}{14}{true}{false}\\
\myXorTF{1}{12}{true}{false}\\
\myXorTF{2}{12}{true}{false}

\newcommand*{\conditionalStuff}[4]{%
  \myXorTF{#1}{#2}
    {\rowcolor{blue!40}#3}
    {\rowcolor{red!40}#4}%
}

\medskip\noindent
\begin{tabular}{@{} l @{}}
\conditionalStuff{1}{14}{true}{false}\\
\conditionalStuff{2}{14}{true}{false}\\
\conditionalStuff{1}{12}{true}{false}\\
\conditionalStuff{2}{12}{true}{false}
\end{tabular}

\end{document}
```

![image.png](/image?hash=51c90ce086f52da6a33bf85f280387fc7ae30bb1b51424e4788109b4f7b58b3c)

Answer #3

निरंजन

I found one way :).

Don't know if it is optimal, would like to know thoughts on this.

```
\documentclass{article}
\newcounter{mycnta}
\newcounter{mycntb}
\newcounter{cntchecker}
\def\checking{%
  \ifnum\value{mycnta}=1\relax
    \addtocounter{cntchecker}{1}%
  \fi
  \ifnum
    \value{mycntb}=14\relax
    \addtocounter{cntchecker}{1}%
  \fi
  \ifnum\value{cntchecker}=2\relax
    true%
  \else
    false%
  \fi
  \setcounter{cntchecker}{0}%
}

\begin{document}
\begin{enumerate}
\item
  \setcounter{mycnta}{1}
  \setcounter{mycntb}{14}

  Should return true. Returns \checking .

\item
  \setcounter{mycnta}{3}
  \setcounter{mycntb}{15}

  Should return false. Returns \checking .

\item
  \setcounter{mycnta}{2}
  \setcounter{mycntb}{14}

Should return false. Returns \checking .

\item
  \setcounter{mycnta}{1}
  \setcounter{mycntb}{15}

  Should return false. Returns \checking .
\end{enumerate}
\end{document}
```

Those levels of optimisation are really micro-optimisations. They might be faster by seemingly much in direct comparison, but if you consider everything else code might do the difference doesn't matter all that much (might be 10% faster *relatively*, but still comparing 1 μs to 0.9 μs is counting peanuts). To give a few numbers: The normal `\expandafter\@firstoftwo\else\expandafter\@secondoftwo\fi` stuff takes with `\ifx aa` and `\ifx ab` about 0.65 μs. Using `\expandafter\@secondofthree\fi\@secondoftwo` or the thing I called `\weirdturntrue` boosts this both by about 7 % to 8 %, and the optimisation I use in `expkv` reaches roughly 12 % speed up (that's 0.57 μs instead of 0.65 μs for evaluating two conditionals)

The `expl3` names for this trick are `\__prg_TF_true:w`, `\__prg_T_true:w`, and `\__prg_F_true:w` if you're interested (and since they start with `__` you might guess they are not meant to be used by code other than the kernel code -- but fear not, `\prg_new_conditional:Npnn` inserts those for you if applicable).

Ah, so to put it in other words you only exploit the conditional to execute what is true and put the other executable material from the false case unconditionally as anyways what was written for true is gonna get gobbled, right?

(To confuse you further, there are actually two steps of optimisations missing to get maximum performance, step 1 is taken in `expl3` (my fault), step 2 is used in `expkv`, I'll only describe step 1 here -- step 2 has worse error recovery compared to step 1 for malformatted input) The following is a possibility to get branching conditionals without the use of `\expandafter` (but it requires specially crafted macros with weird argument signature, which is why they aren't used that often): The basic idea is to exchange the `\@secondoftwo` after the `\fi` with `\@firstoftwo` by expansion. This can be done with a macro that gobbles the `\fi` and reinserts it: ``` \def\weirdturntrue\fi\@secondoftwo{\fi\@firstoftwo} \if<test> \weirdturntrue \fi \@secondoftwo ``` Again our two cases: - `\iffalse`: ``` \iffalse \weirdturntrue \fi \@secondoftwo ``` `\iffalse` gobbles: ``` \@secondoftwo ``` done. - `\iftrue`: ``` \iftrue \weirdturntrue \fi \@secondoftwo ``` `\iftrue` starts the `\if`-block ``` \weirdturntrue \fi \@secondoftwo ``` `\weirdturntrue` gobbles the `\fi` and `\@secondoftwo` and leaves its replacement text: ``` \fi\@firstoftwo ``` `\fi` expands, making the `\if`-block happy: ``` \@firstoftwo ``` done.

I hope the above explains this already. A small addendum because of your `\else`-point: For performance reasons I tend to use `\@secondofthree` and `\@thirdofthree` without an `\else`-block where applicable. But I know that many (most?) TeX-coders use an `\else` block as well, and their branching conditionals look like the following: ``` \if<test> \expandafter\@firstoftwo \else \expandafter\@secondoftwo \fi ``` That's pretty similar to above, but we can take a more thorough look: - The `\iftrue` case: ``` \iftrue \expandafter\@firstoftwo \else \expandafter\@secondoftwo \fi ``` `\iftrue` will leave the stuff immediately following it in the stream and set TeX to be in an `\if`-block. ``` \expandafter\@firstoftwo \else \expandafter\@secondoftwo \fi ``` The `\expandafter`-strangeness (stack description above): ``` % stacked: \expandafter\@firstoftwo \else \expandafter\@secondoftwo \fi ``` The `\else` gets expanded, closing the `\if`-block and gobbling everything up to `\fi` (inclusive), `\@firstoftwo` is reinserted: ``` \@firstoftwo ``` - the `\iffalse` case: ``` \iffalse \expandafter\@firstoftwo \else \expandafter\@secondoftwo \fi ``` `\iffalse` gobbles everything up to the matching `\else` or `\fi` (`\else` in this case): ``` \expandafter\@secondoftwo \fi ``` `\expandafter`-magic happening: ``` % stacked \expandafter\@secondoftwo \fi ``` `\fi` closes the `\if`-block, expanding to nothing, `\@secondoftwo` is reinserted: ``` \@secondoftwo ```

The `\expandafter` only expands the `\fi` before `\@thirdofthree` if it is itself expanded, which it only is if the `\ifnum` is true. So the branching still happens in the `\ifnum`. The two cases are (I'll use `\iftrue` and `\iffalse` for this): - First the easier to understand `\iffalse` case: ``` \iffalse \expandafter\@thirdofthree \fi \@firstoftwo ``` Since the conditional is false everything up to a matching `\else` or `\fi` (`\fi` in this case) is removed, so upon expansion of the `\iffalse` the input only contains the `\@firstoftwo`. - Now the `\iftrue` case: ``` \iftrue \expandafter\@thirdofthree \fi \@firstoftwo ``` The `\iftrue` expands, doing essentially nothing (except starting an `\if`-block for TeX's internal state). So one step of expansion becomes ``` \expandafter\@thirdofthree \fi \@firstoftwo ``` Now the `\expandafter` takes place, `\@thirdofthree` is pushed on a stack to be reevaluated once the following token is expanded. ``` % stacked: \expandafter\@thirdofthree \fi \@firstoftwo ``` The `\fi` expands, closing the `\if`-block and expanding to nothing. The `\expandafter` is done and removed, the `\@thirdofthree` put back ``` \@thirdofthree \@firstoftwo ``` and the `\@thirdofthree` gobbles the `\@firstoftwo` and does the branching.

Because `\@thirdofthree` should be defined long just like `\@firstoftwo` and the like. It might be used by packages, and branching ifs should be able to take an explicit `\par` (so this is by convention).

(The following describes a context outside of `\numexpr`) There is a difference in an expansion only context, because a space terminates TeX's number parsing and is absorbed in the process whereas a `\relax` terminates it and stays there, so in this case you get stray `\relax` tokens that you don't want. (This describes the situation in `\numexpr`) You don't want those because they end the number expression parsing of `\numexpr` (and here they are absorbed). So what happens if you use `\relax` in the inner `\ifnum`s is that you'll get something which looks like this after a few steps of expansion/reading: `\ifnum\numexpr\relax 1\else0\fi=0` and now you have an empty `\numexpr` (the stray-looking `\else` and `\fi` don't hurt, they still belong to the inner `\ifnum` test that'll be closed once the `\else` is expanded down the road).

The performance is slightly slower but only minuscully, since `\space` expands to a single space (so one step of expansion). You could use `\@sptoken` instead of `\space` (that one is `\let` to a space) for better performance.

arbitrary, for the `\checking...` macros starred ones would actually make a bit more sense, but it doesn't really matter. At the end of the day starred vs. unstarred is whether they can absorb explicit `\par`s, none takes an argument, so the difference doesn't really show up. The `\checking` macro of the first code is a different story, here starred `\newcommand` would actually be better.

Currently we have: ``` \expandafter\@thirdofthree \fi \@firstoftwo {true}{false}% ``` How is it different from directly having: ``` \fi {false}% {true}% ``` I tried this with `\checkingAND` and it prints falsetrue everywhere, so I know something is wrong, but exactly what is wrong? The definition of `\@thirdofthree` is just printing the third argument, so if after expanding `\fi`, `\@thirdofthree` gets three arguments respectively `\@firstoftwo`, `{true}` and `{false}` and prints `{false}`, why it doesn't work when we directly write `{false}` instead of `\@thirdofthree`? Also when and how the `\@firstoftwo` (i.e., true) gets invoked??? If all of this is after the `\fi` how the selection still works? Also there is no `\else`, but I still see its effect. What is the bare bone representation of what's happening and when it is happening?

> `\expandafter` simply expands the `\fi` (expands to nothing, closing the `\ifnum`-block) before the `\@thirdofthree` so that the `\ifnum` is complete (if it was true), and `\@thirdofthree` sees as its arguments `\@firstoftwo{<true>}{<false>}` picking up `<false>` Thanks. I understood some part of your explanation, but the basic question I have is as `\@thirdofthree` and `\@firstoftwo` are outside the entire `\ifnum`-block (provided it gets finished before it is typed because of the `\expandafter`); how does it get affected by the branching? (This is why for me `\expandafter` is evil :joy: It does something that I always fail to understand.)

* With [this](https://topanswers.xyz/transcript?room=2023&id=136162#c136162) I was always under the impression that explicit spaces and `\relax`es work the same way in number calculations. However in this case it doesn't seem to be like that, because using `\relax` instead of space fails the compilation. So what is the role of spaces and `\relax`es in number calculations?

* I have tried to rewrite it the following way. Is it safe? You had [once](https://topanswers.xyz/tex?q=1978#a2223) advised to use `count`s instead of `counter`s for storing internal states, hence I tried to use it. The space termination really makes me feel uncomfortable. On one line of your code I saw explicit `\space` command and replacing explicit terminating spaces with that control sequence just worked. Does it make any difference in performance? I just want it to look consistent :P ``` \documentclass{article} \newcount\mycnta \newcount\mycntb \makeatletter \providecommand\@thirdofthree[3]{#3} \newcommand\checkingAND{% \ifnum \ifnum\mycnta=1\space \ifnum\mycntb=14\space 1% \else 0% \fi \else 0% \fi =0\space \expandafter\@thirdofthree \fi \@firstoftwo {true}{false}% } \newcommand\checkingOR{% \ifnum \ifnum\mycnta=1\space 1% \else \ifnum\mycntb=14\space 1% \else 0% \fi \fi =0\space \expandafter\@thirdofthree \fi \@firstoftwo {true}{false}% } \newcommand\checkingXOR{% \ifnum \ifnum\mycnta=1\space 1% \else 0% \fi =% \ifnum\mycntb=14\space 1% \else 0% \fi\space \expandafter\@thirdofthree \fi \@firstoftwo {true}{false}% } \makeatother \begin{document} \begin{enumerate} \item \mycnta 1\relax \mycntb 14\relax AND should return true. Returns \checkingAND.\\ OR should return true. Returns \checkingOR.\\ XOR should return false. Returns \checkingXOR. \item \mycnta 1\relax \mycntb 15\relax AND should return false. Returns \checkingAND.\\ OR should return true. Returns \checkingOR.\\ XOR should return true. Returns \checkingXOR. \item \mycnta 2\relax \mycntb 14\relax AND should return false. Returns \checkingAND.\\ OR should return true. Returns \checkingOR.\\ XOR should return true. Returns \checkingXOR. \item \mycnta 3\relax \mycntb 15\relax AND should return false. Returns \checkingAND.\\ OR should return false. Returns \checkingOR.\\ XOR should return false. Returns \checkingXOR. \end{enumerate} \end{document} ```

@Skillmon, thanks for [your brilliant answer](#a2343), I liked the second approach more, but I have a few questions regarding it. I will list them down in separate messages (without pinging) so that it would be easy to answer them individually.

Well, AND and OR are quite easy to do without `\numexpr`, but I'm not sure how XOR can be implemented with a single conditional (of course, with a bit more parsing steps this would be possible without `\numexpr`. But the reason I preferred the `\numexpr`-approach here is because it's quite easy to understand, and doesn't need different comparison-values in the top level `\ifnum`.

@निरंजन, re: [your answer](#a2342), It works but isn't expandable and is less efficient than Skillmon's way. `expl3` has good support for these things, see for instance `\bool_lazy_and:nnTF` or the syntax for boolean expressions with the `&&` operator in [interface3.pdf](http://mirrors.ctan.org/macros/latex/contrib/l3kernel/interface3.pdf) (using `\bool_lazy_and:nnTF` gives faster code).

3 Answers