Mfcttrf

is implementing a function to find the absolute value like this:

uint16_t absolute_value(int16_t n)

 int16_t mask = n >> 15;
 return((n+mask)^mask);

Any quicker than just doing a simple multiply by -1 if less than 0? this code is on a microprocessor where speed is everything.

The standard C library is providing the optimized solutions for many problems with considerations based on the architecture, compiler in use and others. The abs() function defined in stdlib.h is one of these, and it is used for your purpose exactly. To emphasize the point, here is ARM compiler result when using abs vs a version of a homebrew abs: https://arm.godbolt.org/z/aO7t1n

Paste:

#include <stdio.h>
#include <stdlib.h>

int main(void)

 srand(111);
 int x = rand() - 200;
 printf("%dn", abs(x));

results in

main:
 push r4, lr
 mov r0, #111
 bl srand
 bl rand
 sub r1, r0, #200
 cmp r1, #0
 rsblt r1, r1, #0
 ldr r0, .L4
 bl printf
 mov r0, #0
 pop r4, pc
.L4:
 .word .LC0
.LC0:
 .ascii "%d1200"

And

#include <stdio.h>
#include <stdlib.h>

int my_abs(int x)

 return x < 0 ? -x : x;


int main(void)

 srand(111);
 int x = rand() - 200;
 printf("%dn", my_abs(x));

results in

my_abs:
 cmp r0, #0
 rsblt r0, r0, #0
 bx lr
main:
 push r4, lr
 mov r0, #111
 bl srand
 bl rand
 sub r1, r0, #200
 cmp r1, #0
 rsblt r1, r1, #0
 ldr r0, .L5
 bl printf
 mov r0, #0
 pop r4, pc
.L5:
 .word .LC0
.LC0:
 .ascii "%d1200"

Notice that the main code is almost identical in both codes as the my_abs got inlined, and it's implementation is the same as the standard one.

The speed of a given solution will depend greatly on the architecture, but in C I would say

return (n > 0 ? n : -n);

and let the compiler figure out the best solution.

EDIT: @jonk points out correctly that this will fail for the most-negative possible value of n, assuming that two's-complement arithmetic is used.

Yes, my solution has a conditional branch, but yours has an arithmetic operator and two bitwise operators. Can your microcontroller shift 15 places in a single clock?

There are a lot of subtle details in using C. Given your comment about speed, it is probably worth your time to try out various options and see which produces better assembly code results. Ask the compiler to generate assembly code and then read it. (This doesn't always catch the reality, though. Some compilers leave certain replacements to the linker step.) Or use the machine code and a disassembler and just look. (That always works.) It's not hard to do once you've worked out the steps in your situation.

Let me just suggest some options to consider. Perhaps that's the best I can do. (I'm assuming below that you don't want to take the absolute function of a constant, since there is an obvious "code time" solution for that case.)

1. The abs() function that's available for your C compiler may very well be implemented in-line with the compiler. (Microsoft's x86 C compiler certainly does this.) If this is already handled within the compiler, looking at the machine code will tell you what you need to know. Sometimes, the assembly output isn't a sufficient test since some compilers will leave this optimization step to the linker process, instead. In those cases, you will have no choice but to examine the final machine code product.


2. You can attempt to use the method you already mentioned (using an if statement or using the trinary ? operator.) Again, I've seen versions of Microsoft's C compiler that will eat these perfectly well and generate exactly the same case as if you'd used their in-line abs() version -- which for some targets will generate code without any branching involved and taking two or three instructions.


3. You can use the method you've coded up (which is dependent on your word size.) You've coded one method: $left(n+maskright), text^, mask$.


4. You could try: $left(n, text^, maskright)-mask$.


5. You could try: $n-left(left[n << 1right], &: maskright)$ or $n-left(2,n, &: maskright)$ or $n-left(left[n+nright], &: maskright)$.

There are other options if you have a fast multiply for +1 or -1 (sometimes, that's easy.)

Be wary of, and follow, the C standards. Often, operations on negative signed values are undefined. They may behave as expected. But that behavior may not be portable or guaranteed.

As a final note, if you intend on writing a function in C it may pay to provide the compiler hint to make it an inline function.