Page 1 of 1

[0.17.45] Arithmetic Combinator: right-shift (>>) not working correctly on negative numbers

Posted: Tue Jun 04, 2019 5:07 am
by infinitysimplex
One of the combinator bugs that have been bugging me ( :mrgreen: :roll: ) for a long time now. Finally having the resolve to open a bug thread. I've been looking up and down the reports, known issues etc., apologies if it's already been reported.
  • Synopsis: Bitwise right-shift operation of arithmetic combinator (">>" operation) behaves like division by 2
  • Factorio Version: 0.17.45 (build 45219, linux64, steam)
  • Example:
    • Screenshot (explanation below):
      file.png
      file.png (917.5 KiB) Viewed 2903 times
      The lights display the signal "X" bitwise. With proper bitshift, the last two rows should be identical.
      The constant combinator on top sets X=1.
      The first row of combinators does X << 31 (left) or nothing (right).
      Second row does X >> 1 (left) and X << 30 (right), giving identical outputs if bitshift were working correctly. The difference in the outputs is clearly visible.
      The last row does X >> 30 (both left and right), giving output X=1 if bitshift were working correctly. Again, the difference is clearly visible, being X=1 and X=-1, in two's-complement-encoding.
    • Blueprint string:

      Code: Select all

      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
      
  • Reproducible: Always
  • Suspected cause: ">>" implemented by divison by 2 instead of bitshift. Maybe correspondingly for "<<".
  • Impediment: Low
  • Workaround and required effort: Separate negative and positive signals, handle them differently. Minor effort for typical players, medium for extravagant combinator setups.
  • Fixing effort: Minimal. Implement by bitshift, either using Lua's bitshift operation (I hope Lua has some sort of stdlib...) or bindings to C/C++ bitshift functions. This should also give a major performance boost for these operations since the libraries should transparently hand them to the CPU, computing it in hardware. Same goes for all other bitwise operations.
There were some similar bugs and inconveniences. I'll try to verify them in the current version and post them here or in the suggestions section, respectively, as soon as I can find the time.
Thanks for looking into it! :)

Re: [0.17.45] Arithmetic Combinator: right-shift (>>) not working correctly on negative numbers

Posted: Tue Jun 04, 2019 5:25 am
by Rseding91
Doing a quick search yields this: https://stackoverflow.com/questions/185 ... mbers-in-c

And looking at the logic all it's doing is this:
shifts.PNG
shifts.PNG (10.59 KiB) Viewed 2899 times
Which leads me to believe that this is all working "as intended" and isn't likely to be changed. I'll leave that up to Twinsen though.

Re: [0.17.45] Arithmetic Combinator: right-shift (>>) not working correctly on negative numbers

Posted: Tue Jun 04, 2019 5:43 am
by DaveMcW
DaveMcW wrote: Fri Apr 28, 2017 6:01 am I would love to have a >>> operator for logical shift instead of arithmetic shift.

Any bitwise operation that touches the sign bit is very awkward to do without it.

Re: [0.17.45] Arithmetic Combinator: right-shift (>>) not working correctly on negative numbers

Posted: Tue Jun 04, 2019 9:14 am
by Twinsen
We are going for whatever C++ sets as standard, so it's indeed working as intended.

Re: [0.17.45] Arithmetic Combinator: right-shift (>>) not working correctly on negative numbers

Posted: Tue Jun 04, 2019 12:09 pm
by mrvn
Twinsen wrote: Tue Jun 04, 2019 9:14 am We are going for whatever C++ sets as standard, so it's indeed working as intended.
C++ has both arithmetic (signed) and logical (unsigned) shift depending on the type of variable. But signals seem to be int32_t so arithmetic shift it is.

Re: [0.17.45] Arithmetic Combinator: right-shift (>>) not working correctly on negative numbers

Posted: Tue Jun 04, 2019 9:49 pm
by infinitysimplex
Ah, I see. So It's indeed what your C/C++ implementation does. Thanks for the quick answers, that was basically all I wondered. :)
Actually, considering it's the arithmetic combinator, not the logical, I could have expected that it does arithmetic shift, not logical. It just never occurred to me until now. My bad. 🤦

Sorry for the disturbance, and thanks again. :)

Re: [0.17.45] Arithmetic Combinator: right-shift (>>) not working correctly on negative numbers

Posted: Mon Jul 26, 2021 7:39 pm
by DaveMcW
Halke1986 discovered a trick to turn a signed right-shift into unsigned right-shift. You flip the sign bit and right-shift, then add two copies of 2^30 right-shifted. This can be done with a single constant combinator.

The complete solution includes an extra combinator to handle the special case of right-shifting by 31.



unsigned_right_shift.jpg
unsigned_right_shift.jpg (87.37 KiB) Viewed 2437 times