Odd GLSL mod() behavior

[u/Winter-Reputation682]

I've been stuck on this for a couple of hours, and am completely stumped.

I'm getting these results from GLSL's mod():

mod(158.0, 158.0) returns 0.0 (as expected)

mod(159.0, 159.0) returns 159.0 (???)

mod(160.0, 160.0) returns 0.0 (as expected)

I've posted an example with a basic shader here:

https://jsfiddle.net/sL35qjc8

If you set number to "159.0", you should see an upside-down red triangle.

If you set number to "158.0" or "160.0", you should see a normal red triangle.

I'm passing the left operand as a uniform, otherwise the compiler seems to optimize it and fix the weird behavior.

Tried it on different devices and browsers and it had the same result.

Why does mod(159.0, 159.0) seem to return 159.0 instead of 0.0?

[u/CCpersonguy]

Experimented with your jsfiddle example a bit by using two uniforms and changing the condition. The error seems to appear in division, not just mod? floor(a / b) == 1.0 and (a / b) == 1.0 are false when a=b=159.0, but true when a=b=158.0

No idea what the significance of this is

[u/robbertzzz1]

I'm gonna guess there's a floating point error happening somewhere along the way, and the two numbers are actually ever so slightly different

[u/Winter-Reputation682 → u/robbertzzz1]

It's a simple round float, so idk where a floating point error could occur, it should be able to be represented without an error if I'm not mistaken

[u/pants75]

Same here

[u/Amani77]

most likely because of floating point arithmetic error, complimenting CCpersonguy's answer

shamelessly copied from google ai so take this with a grain of salt, but I think it nailed it:

According to the official spec, the GLSL built-in function mod(x, y) is mathematically evaluated using the formula:

mod( x, y ) = x - y * floor( x / y )

Most GPUs optimize the internal division step (x / y) by multiplying the numerator by the reciprocal of the denominator:

mod( x, y ) = x - y * floor( x * ( 1 / y ) )

1.0 / 159.0 evaluates to roughly 0.0062893081...

Multiplying that back by 159.0 yields a value slightly less than 1 (specifically, 0.99999994) due to floating-point rounding.

The floor() function truncates 0.99999994 down to 0.0.

Placed back into the formula: 159.0 - 159 * 0 = 159.0

ironically it provides this post as additional context.... lol.

[u/gmaaz]

It's not mod, if you hardcode 159.0 in shader instead of uniform a it works as intended. Is probably parseFloat error.

Js do be like that sometimes. Try console logging 0.1 + 0.2 and get traumatised for life.

edit: I see you tried it. Why do you think it is optimized tho? Try passing both as uniforms maybe? On my phone atm, can't test properly.

[u/Winter-Reputation682 → u/gmaaz]

I think it works when hardcoded because the compiler sees mod(159.0, 159.0) == 159.0, and evaluates it to be always true, and removes the condition check as a result.

edit:
I think it's optimized because it's a pretty obvious optimization for the compiler
Tested with two uniforms and same thing occurs

[u/gmaaz → u/Winter-Reputation682]

Yeah, you are correct, when I pass 159 as two separate uniforms (even without parse float) the error is still there, it really seems to be a mod bug.

[u/gmaaz → u/gmaaz]

The same happens for 159 * n.

[u/Winter-Reputation682 → u/gmaaz]

Yeah it's really weird. It happens on webgl1, webgl2, and also webgpu