Convert conditional logic for edge wrapping to math expression - algorithm

Question

I have a simple function that takes a float parameter x in the range [-1.0, 2.0] and maps it to range [0.0, 1.0] such that values below 0.0 are mapped to 1.0 and values above 1.0 are mapped to 0.0:
float wrap_ternary(x) {
// result is between [0.0, 1.0]
return x < 0.0 ? x + 1.0 : x > 1.0 ? x - 1.0 : x;
}
I want to convert that function to use math expressions instead of conditionals. I've come up with the following algorithm:
float wrap_mod(x) {
return (((x + 1.0) % 2.0 + 1.0) % 1.0);
}
However the edge wrapping of this algorithm is inclusive i.e. 1.0/2.0 are mapped to 0.0 whereas the ternary version would map these values to 1.0:
X
wrap_ternary
wrap_mod
wrong
-1.0
0.0
0.0
-0.5
0.5
0.5
0.0
0.0
0.0
0.5
0.5
0.5
1.0
1.0
0.0
x
1.5
0.5
0.5
2.0
1.0
0.0
x
How would I modify my algorithm so that it produces the same results as the ternary version? I've tried to subtract EPSILON from my modulo but that didn't really work... I just can't wrap my head around this. No pun intended.

Answer 1

I am not familiar with GLSL, but it seems to be quite similar to C. So below is a C solution wrap_floor() that uses the floor() function to implement the conditional addition or subtraction, together with a test framework that tests it exhaustively.
The only issue is getting the switchover points correct, which would naturally fall on integers. The question already mentions "epsilon techniques" in which one increases or diminishes floating-point numbers by one ulp (unit in the last place) and which can be used to shift the bounds slightly. To get the correct shift for this case, we need to multiply the input by the "magic" multiplier (1 - 1 ulp). Assuming that float maps to the IEEE-754 binary32 format, the desired number is the literal float constant 0.99999994.
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
// result is between [0.0, 1.0]
float wrap_ternary (float x) {
return x < 0.0 ? x + 1.0 : x > 1.0 ? x - 1.0 : x;
}
float wrap_floor (float x) { return x - floorf (x * 0.99999994f); }
int main (void)
{
/* exhaustive test of wrapping functions over [-1,2] */
float x = -0.0f;
while (x >= -1.0f) {
if (wrap_ternary (x) != wrap_floor (x)) {
printf ("x=% .9e wrap_ternary = % .8e wrap_floor=% .8e\n",
x, wrap_ternary (x), wrap_floor (x));
}
x = nextafterf (x, -INFINITY);
}
x = 0.0f;
while (x <= 2.0f) {
if (wrap_ternary (x) != wrap_floor (x)) {
printf ("x=% .8ef wrap_ternary = % .8e wrap_floor=% .8e\n",
x, wrap_ternary (x), wrap_floor (x));
}
x = nextafterf (x, INFINITY);
}
return EXIT_SUCCESS;
}

Answer 2

This might work as expected, though...
float wrap_somehow(x) {
return 0.5 - (frac(1.5 - abs(x - 0.5)) - 0.5) * sign(x - 0.5);
}

Answer 3

The frac function, which returns the fractional part of a float, seems to have the behaviour you want for all inputs other than 1.0 and 2.0. So this would work:
float wrap_ternary(x) {
return (x == 1.0 || x == 2.0) ? 1.0 : frac(x);
}