Implement OpenGl-like MIRRORED_REPEAT - c++

Question

I am supposed to implement a MIRRORED_REPEAT for my raytracing textures. I looked at how it's defined in OpenGL https://www.khronos.org/registry/OpenGL/specs/gl/glspec46.core.pdf page 260 and then I tried it myself, first with a 1-dimesional array. The behaviour should be:
Basically it repeats the index into the array ( modulo ) but mirrors the input based on wether or not the offset is even or odd. ( 2nd image below )
#include <iostream>
int main() {
int values[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
const auto mod = [](const int a, const int n) noexcept
{
return (a % n + n) % n;
};
const auto mirror = [](const int a) noexcept
{
return a >= 0.f ? a : -(1 + a);
};
const auto mirrored_repeat = [&](const int x) noexcept {
return (10 - 1) - mirror(mod(x, 2 * 10)) - 10;
};
for(int i = -5; i < 6; ++i) {
std::cout << values[mirrored_repeat(i)] << std::endl;
}
}
This doesn't work however, but gives me nice undefined-behaviourish output instead x) Can someone tell me how I can do it properly?

Answer 1

If you replace the line
std::cout << values[mirrored_repeat(i)] << std::endl;
with
std::cout << mirrored_repeat(i) << std::endl;
you'll see that the indices returned by mirrored_repeat are clearly wrong (they are negative, to begin with).
I believe the formula in the spec is a bit wrong, for it has one mismatched bracket. If we rewrite the line
return (10 - 1) - mirror(mod(x, 2 * 10)) - 10;
like this
return (10 - 1) - mirror(mod(x, 2 * 10) - 10);
the code starts producing something more reasonable.

Answer 2

For anyone interested, I derived a shorter solution while working on Blender:
C++
#include <iostream>
int main() {
const auto mirrored_repeat = [&](int x, const int size) noexcept {
x = std::abs(x + (x < 0)) % (2 * size);
return x >= size ? 2 * size - x - 1 : x;
};
for (int i = -6; i < 5; ++i) {
std::cout << mirrored_repeat(i, 10) << std::endl;
}
}
JavaScript demo
function mirrored_repeat(x, size) {
x = Math.abs(x + (x < 0)) % (2 * size);
return x >= size ? 2 * size - x - 1 : x;
}
for (let i = -6; i < 5; ++i) {
console.log(mirrored_repeat(i, 10));
}
I wanted to reduce the number of modulo calls, so I used the symmetry of C++ modulo for odd sections and the if statement for even sections.
For information on how I derived it, see my explanation here.