For positive numbers where you want to find the ceiling (q) of x when divided by y.

unsigned int x, y, q;

To round up ...

q = (x + y - 1) / y;

or (avoiding overflow in x+y)

q = 1 + ((x - 1) / y); // if x != 0

Note that truncate (rounding towards 0) is not the same as floor (rounding towards minus infinity), and hence the oposite of truncate would always round away from zero, which is not the same as ceil (rounding towards plus infinity).

The following implements the opposite of truncate, so this is not ceil but always rounds away from 0. To get the same level of optimisation this uses several TeX primitives, which are marked as :D in expl3 (so this is evil code!).

\ExplSyntaxOn
\cs_new_eq:NN \__wamseln_sep: \tex_let:D
\cs_new_eq:NN \__wamseln_int_eval:w \tex_numexpr:D
\cs_new_eq:NN \__wamseln_int_eval_end: \tex_relax:D
\cs_new:Npn \wamseln_div_away:nn #1#2
  {
    \int_value:w \__wamseln_int_eval:w
      \exp_after:wN \__wamseln_div_away:w
        \int_value:w \__wamseln_int_eval:w #1 \exp_after:wN \__wamseln_sep:
        \int_value:w \__wamseln_int_eval:w #2 \__wamseln_sep:
    \__wamseln_int_eval_end:
  }
\cs_new:Npn \__wamseln_div_away:w #1#2\__wamseln_sep: #3#4\__wamseln_sep:
  {
    \if_meaning:w 0#1
      0
    \else:
      (
        #1#2
        \if_meaning:w -#1 - \else: + \fi:
        ( \if_meaning:w -#3 \else: #3 \fi: #4 - 1 ) / 2
      )
    \fi:
    / #3#4
  }
\NewDocumentCommand \test { m m m }
  {
    \int_compare:nNnTF { \wamseln_div_away:nn {#1} {#2} } = {#3}
      { \message{.} }
      {
        \msg_error:nneeee { wamseln } { test-failed }
          {#1} {#2} {#3} { \wamseln_div_away:nn {#1} {#2} }
      }
  }
\msg_new:nnn { wamseln } { test-failed }
  { Unit~ test~ failed!~ away((#1)/(#2))=(#3)~ but~ was~ (#4) }
\ExplSyntaxOff

\typeout{Tests:}

\test{21}{5}{5}

\test{-21}{5}{-5}

\test{21}{-5}{-5}

\test{-21}{-5}{5}

\test{2}{4}{1}

\test{-2}{4}{-1}

\test{2}{-4}{-1}

\test{-2}{-4}{1}

\stop

The most glaring optimisation this code takes is to check whether a number is positive, negative, or zero by just taking a look at the first token of the result of \numexpr.

• Iff the number is zero the first token is 0 (and that's also the only token)
• Iff the number is negative the first token is -
• Else the number is positive

The fastest check in TeX is \ifx (\if_meaning:w in expl3), so it makes sense to favour it over \if_int_compare:w where possible (slowish by comparison) or even \str_case:nn (horribly slow!!!). (Please note that the aforementioned performance categories are meant in the context of low level optimisation of TeX code, none of the three mentioned options is horribly slow from a user's point of view per se, though one should avoid \str_case:nn in the inner loop of some often called procedure)