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

Bugs that are actually features.
User avatar
infinitysimplex
Burner Inserter
Burner Inserter
Posts: 14
Joined: Fri Jul 28, 2017 8:26 pm
Contact:

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

Post 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 2900 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

      0eNrtnd1uHEeShd+FtysuOiL/BcPAAnu91wssDIOWOWMCEiVQlLGGoQfYt9hn2ydZklKN7e6KznMKY2cGqm9mIMtuSRFK1sevMuL8evXD20+3Hx7u7h+vXv96dffm/f3Hq9f/9evVx7u/39+8ff5nj798uL16fXX3ePvu6tXV/c275x/dPNw9/vTu9vHuzfWb9+9+uLu/eXz/cPX51dXd/Y+3/331Wj5/9+rq9v7x7vHu9ssHvvzgl+/vP7374fbh6V/ofNSrqw/vPz791+/vn38PT594HcKrq1+e/j//a3r6dX68e7h98+Wn46urp9/248P7t9//cPvTzc93T//503/z2+d+//TTP7581sfnn/jb3cPHx+9P/oA/3z08fnr6J//4jX35N67/8/mP9fH2+TOeP+jj481zreRQQolS9elXf//h9uHmy+/l6t/+49+fPuH9p8cPn7hf4/Pnlz/G/Zc/1ctvVJ7/5+H2x9/X7+7pR/r0b949vPl09/jyQ/n86g8/HY9/+runj1bjs0J8+unPv/uEpUHKNyjO1KBrlVhiDTnWv75DQrUgGC0IfAtkphakkGs5NNG/vgHx/BHJVH+y0Z/I90dn6o/mGkOKKf/1/Qnn+8Odn2T0J9H90TZTf3KRQ615wBMmn29PpdpTjfZk/vgcpkKAEFVK0QHPl3S+P4HqTzH6U/jjU6bqTy5P3ZEBX91q56vbgelPPBj9qXx/6kz9CSGlGMMAOijn+5Oo49OM9jS+PWmm9kRpMRwGPHxOj8fR8VHq+KjRn+dfhm1QnqlBNTzBwWHA06ed70+h2iNWe3hDoJMZglhTGfD0kY4fEEoQREsQCG8IdCpDoIdWJA14/Iicb1Cj+mPZA+H1gcpc356qxBHPn448EMoeRMseCK8PdCp9kDRqHSHXevKAsgfRsgfC6wOZSx+kFEY8fjryQCh7EC17ILw+0Mn0gRzKiKdPRx4IZQ+iZQ+E1wcymT4IdcTTpyMPlJMH1nenwtsDmcseaMkjHj4ddyCUPEiW2xHeHshc9uDQBjx7tKMOlFIHyVIHyqsDmUsdSBvx5OmIA6HMQbLMgfLmQCYzB0NuFXS0gVLaIJn3CnhtIJNpgxE3CrTjDISSBsmSBspLA5lLGox4m60dY6CUMUiWMVDeGMhcxmDEVRDt6AKldEGydIHyumAuWzDikdNRBUqpgmSpAuVVgcylCkbcMdCOJ1DKEyTLEyjvCSbTBANa03EEgXIE2fomVHlHMJkiGNCajh9Qzg9Y+kZ5PzCXHhhw5bDjBgLlBrLlBgLvBuZSAwPOTMcLKOUFsuUFwoaZg6meNAPOTMcJ5HS+FZYECLwEmMsBDGhFRwAoJQCyOXPwmwD4+O7m7dvrtzfvPpwZ9kif1+u//Fb+UfwNtb+5/+Xxp7v7v199+TW+1v75y/j7dx9uHl7+ory++r//+d+r7cMz5pfxCNYhOK2DgHVIYB3UaR0iWIcM1kGc1iGAdShgHQ5O65DBOlSsDstEibs6JLAODaxDdVqHitUhHsA6FKd1KGAdBKxD9vrcPICFULAQyWkhGlgHECjVK1AKSJQRJEp1S5QgUkYQKdUrUgrIlBFkSvXKlAJCZQShUr1CpYBUGUGqFK9UKSBWRhArxStOCchTCeRK8crXAgJ2AsFSvIKlgmCZQLAUr2ApIFkmkCzFraoEyTKBZCleyVJBskwgWYpXslSQLBNIluKVLBUkywSSpXglSwXJMoFk6RUsFQTLBIKlV5xSEKcyyJVe+VpBvs4gVnqlygBSZQap0itUKgiVGYRKr0wZQKbM6Ptvr3UAkTL/hpTLr925OfxbQfq3VP529/bx9sHYuHr2Ssqb95++3gn6bePqP+8ySetcMG0rl01Wq5c3r3nV3a95zZ2rpJm68SPmmtFcNq961cuq15y5LphfaOrmba+6922vubeRSrgeWTM+uW3e+Kp73/iaO48U9hxZV0vLYfPWV9351tfSoYISuBaZi0Vl8+ZX3fvm19KZYsiV65E1a1p08/ZX3fn219IZOC2Ja5E1A1TC5gWwuvcFsJ25hnLgWmRNnpa4eQms7nsJbOlMnxZqJkjMNaMlbd4Cq/veAls6Sw+Kch2yplBL3rwIVve9CLZ0BELhBIK5abSUzZtgdd+bYEtnAUKJXIcsuVDq5l2wuutdsKVjFipnFsxlo6VtXgaru14GWzpaoXBawdx2XQ+bt8HqnrfB1o5TqJxTMNeNVtm8DlZ3vQ62doRC4YSCue666uZ9sLrnfbC1YxMqZxPMfco1bF4Iq3teCFs7KqFyKsFc2Fvj5o2wuuONsLXjESrnEcylozVtXgmrO14JWzsSoXISwdynXPPmnbC6452wtWMQKmcQzLWjtWxeCqs7XgpbezmNnD4w913XunkrrO53K2ztuIPGuQNz82htm9fC6n7XwtaOOKicODD3XbfD1r2wutu9sK13PZGTBubu0SabF8PqfhfDto4xqJwxMNddN926GVZ3uxm2dWxB42yBuX+0ha2rYXW3q2FbxxQ0zhSY665b3LobVve6G7Z1LEHjLIG5grSlrcthda/LYVvHEDTOEJjLrlveuh1W97odthVuikQ7rbHsQCtbt8XqXrfFto4ZaJwZMLddtw1mYCoOODo233zz51+EP78zudc5XQvFWG0NrQUGdeb25s1Pq805/LE3/7KhNV8++5/XHTl0E+bA0biXT+L6Ey5DV8b8oR6nYR04t2YuKn/5IK5L8TK/CJ4VOZDsZkY1H2hVkC5jWdZJOW4SJ9uymXd+oJ1Bvsw3WgfluEkkz5mpzQdaHpTLZJZ1UI6bxMm3bEafH2iNUC8TjsY5Oe4R99onm/naB9ontMtslnFMjnvE2bhihmwfaLEw2eufYTOOK+fkuEncW6Bif59EK4a57h4MG9BaOSfHPeKu7xQ1e8S7Br2MOa4fk6MeCfdWqFgS9eWDyB6Fy5DW+jE57hFnG4ppG4S2DRIvo47rx+S4R5xrKKZrENo1zHUPe9Sk1sopOW4RZxqKaRqENg1z3cUeNe24ckiOW8R5hmJ6BqE9w2TTQIPGtVYOyXGLOMtQTMsgtGWYayBo0MTjyhk57hDnGIrpGIR2DHPNpA4a2Vo5Iscd4gxDNQ2D0IZhsqnUMUOPK0fkuEOcXqimXhBaL8y1GWHM3NbKCTluEOcWqukWhHYLc21GGDP3uHJAjhqknFioplhQWixouMxurRyQ4wZxVqGaVkFpq6DxMvu4ckCOG8QphWoqBaWVwlxb4oYMcK2cj+P+cD6hmj5BaZ8w1464IeOPK8fjuD+cTKimTFBaJky2q3TIfQXtmQTlTEI1TYLSJmGuRaVDripoTyMopxGqqRGU1gja9j7MtXI4jtvDOYRmOgSlHcJk27KHPHx6AkE5gdBMgaC0QJgrt2HIo6dnD5SzB820B0rbg7kSG4Y8eXrqIHDqoJnqIPAzEGHnk10rR+O4O5w3aKY3CLQ3mCsXaMBIJH00TCcQwEC+peTiLYEtgwmNEsBIvuVLg79KZLQSaCifeq1EQysBJj0vqOWvEhWtBBj1vHxP4K4SRdBKgFnPyzev/ipxQCsBhj0vlsVfJQJaCTDuefGB/ioB5rlKBAOfF3PtrxIJrQQY+by8Y/FXiYhWAmRM9cqYBWXMCDKmemXMgjJmBBlTvTJmQRkzgoypXhmzoIwZQcZUr4xZUcaMIGOKV8asKGNGkDHFK1lVmKxAxhSvtF1R2k4gY4pXxqwoYyaQMcUrY1aUMRPImOKVMSvKmAlkTPHKmBVlzAQypnhlzIoyZgIZU7wyZkUZM4GMKV4Zs6GMmUDG9IqYDUXMBCKmV65qMFeBhOkVtRuK2hkETK982VC+zCBfesXLhuJlBvHSK102lC4z+pbcayFQuMwYXHqtw8lWTbsQGFtGt4VAgSpjaJncFgJ+fGJkmd0WAgWqjJFlcVsI+PGJkWV1WwgUqApGls1tIdDHZ8HI0u234Sdb8exKYGjpVs2c7J6zK4GxpVtdd7Lhza4EBpduFe7JHjW7EhhdutX6J+vK7EpgeOn2Vc/JVjC7Ehhfun39d7J8y64EBphuX46fLLmyK4ERptuX4yfLpMxKVAwx3V4dOVnaZFcCY0y314lOtiPZlcAY0+0Vs5M1RHYlMMZ0e+3wZN+PXQmMMd1eRT1ZrGNXAmNMt9eTT1bY2JXAGNPtlfWTZTF2JTDGdDvGcLKWxa4ExphuR1tONqDYlcAY0+2408myEbMSDWNMtyNwJ3s97EpgjOl2LPJkh4ZdCYwx3Y7KnuyrsCuBMabb8emT3RB2JcCX5G4ZM6CM2TDGdLtm4WQdiF2JDQnoX/5+yCXrtJeFLo3aaKRmGLpsSEP/+pdXLsHB0jLXBvu08MnnX5+wsvs409ZZYaRcfLPawcB8CPqyPEV2nwzcemvA2LNkLZpSPgp9WeIhOw801V58s3LxzWomAyufhL7snJG9RwNrNwm9Va5L2eyS8kepzNSlYZGm2stvVi6/Wc1sYOWT0JdVPbLzcGDtJaGvHLXzTapmkyLfpDRRk4ZlmmovwFm5AGc1s4GVD0Jf9hvJvrOBtReEvnLQzvfoYPaI1wo6l1YYlGmqvfxm5fKb1cwGVj4IfdkJJfvOBtZeDvrKQTvfIzV7xAsHlam+lR0Taqq9+Gbl4pvVjAZWPgZ9WaMlu44G1l4K+soxO98iUzXwKejLLifZc6ip9sKblQtvVjMZWPkM9GXvmOw6GVh7Eegrp+x8i0zJwEegL2vAZM+pptrLblYuu1nN7GblE9CX9WSy52Rg7QWgrxyy8x0yHRAfgL4sC5Mdx5pqL7pZuehmNYOBlY8/X/bayY6DgbWXfr5yxM43yBQLfPr5slpNdhxrqr3kZuWSm9UMBlY+/HzZAig7DgbWXvb5yhE73yBTKfDZ58siOtlvrqn2gpuVC25WMxdY+ejzZWWi7DcXWHvJ5ysH7Hx/TJnAJ59fT+USRjx+eqnNyqU2q5kKrHzs+bJcUvabCqy91POV43W+P6ZF4FPPr+eSCCO60zMIXGazmqHAymeeX88lEEZ0p2cPlLMHZqK28onn11PJgxHN6ZkDLrBZzURg5ePOr6cSByOa07MGylkDM01bdcOUw0xPnRHN6RmDtQGsc80xjQEfdX49lTAY0ZyeLVDOFphR2qobbMG8J+fbb//03jTuWPQ6GdIKea93ivYGMzXq+db47zv1zTd/fqca1alw6HWqgZ3aEIB+GeVazstJ046+8nFB6GoGoSsfhB4vc5HYUdFAgp0pSwOtE9Jl0Ms4J8c94pRcM5VPoKVCvoxMGsfkuEck5pnaNNBqoVymvIxjctwjTs41U/8E2jDUy7jk+ik5bhH3bqiZ/jTQnqFdJrzWD8lxiyhPFw6mCgq0bZjr/dC4UcnQkw6hcj2yv0GipcNUNxTGDXiFnrQLjWuR6YUCbxv0Mie5ekiOWhQPXItMrxppzTDVTblx412hd9cnCtci0zFE2jFIvExJrh6S4xYp1yLTMETaMEx1Y3vYdFfs+YUYuA6ZfiHSfmGqK9vDRiRjzy7EyHXItAuRtgtzTQ6NGu6KPbcQE9ch0y1E2i1MNTk0akAy9sxCzFyDTLMQabMw1QTrqNGu2PMKkfMKYnqFSHuFuQZYB01Hxp5UiJxUEFMqRFoqTLVJYdBkV+wZhcgZBTGNQqSNwlRrFAaNRsaeTkicThBTJyRaJ2i4zHXFnktInEsQ0yUk2iVovAxGpp5ISJxIEFMkJFokTLVZbsxYV+pZhMRZBDEtQqItwlRL5cZMRaaeQkicQhBTISRaIcy14XTI3YTU8weJ8wdi+oNE+4OpdpsOuZaQevIgcfJATHmQaHmgbe9jXalnDhJnDtQ0B4k2B3Ot2B7y4Olpg8RpAzW1QaK1wVSJD0MeOz1nkDhnoKYzSLQzmCroYchTpycMMicM1BQGmR9zCDuf60o9W5A5W6CmLci0LZgqT2jERCR7MEwTkLFsviXBKbhLH2tgSqHmAFYieK1ERisRwUqo10o0tBIJrIR4rURFK5HBShx8VuIkx8iuBJb/vAREOazEAa1EBStRvVYioJVoYCWK10qA6ehaDmAlstdKJLQSAlYiea1ERCsBMqZGr5VAGbOAjKnBayVQxiwgY6p6rQTKmAVkTBWvlUAZs4CMqV4ZU1DGLCBjilfGFJQxC8iY4pWsBCYrkDHFK20LStsVZEzxypiCMmYFGVO8MqagjFlBxhSvjCkoY1aQMcUrYwrKmBVkTPHKmIIyZgUZU7wypqCMWUHGFK+MqShjVpAxvSKmoohZQcT0ylUKcxVImF5RW1HUbiBgeuVLRfmygXzpFS8VxcsG4qVXulSULhv6ltxrIVC4bBhceq1DQJ+eDUNLrwcjoDjVMLD0+pUywM9ODCu9PjoDClMNo0qvLBXgJycGlV7hOoAoFQ4YU3r9bitktA4YUrr9/jsUtBAYUrpVMqGihcCQ0q2lCw0tBIaUbsVtPKCFwJjSrcuPghYCg0q3r3eiooXAqNLtG78Y0EJgWOn2dXiMaCEwrnT7NjyiYCkYWLq9KhJRshSMLN3eHoooWQpGlm4vlEWULAUjS7d3DCNKloKRpdtrpwklS8HI0u1N5ISSpWBk6fZyekLJUjCydDuvkFCyFIws3Y6wJJQsBSNLt1NNCSVLxcjS7aBbQslSMbJ0O/uYULJUjCy9jsOeLKSwC4GRpdcJ6ZPlD3YhwNfgXskyo2SpGFl63aNwsu3DLsSGfPMvfzvS7tNKQy/pPCi3rshMOg8bks6//t1Nl+jfoNw6vGafFj7T/OvTNe09knTlLBwdFi5/OZjRvoHPM1+Wo6S9h/u+/A0//yWNPEvWHqnAZ5kvSzrSzmNJQy+BOXAJzMFM9w18lPmyUybtPd839LLMV87a+S5ls0vKH6UyU5eGRZOGXghz4EKYg5nwG/gw82UVT9p5xm/opZmvHLXzTapmkyLfpDRRk4alk4ZeDnPgcpijmfEb+DTzZX9R2nfIb+jFma8ctPM9Opg94rWCzqUVBuWThl4Qc+CCmKOZ8hv4PPNl51Pad8xv6OWZrxy08z0yhQOfZ75sHkq7jigNvSTmwCUxRzPmN/B55suarLTrnN/QyzNfOWbnW2SqBj7PfNnVlPYcUhp6ScyBS2KOZs5v4OPMl71iaddBv6EXZ75yys63yJQMfJz5suYr7TmnNPSimAMXxRzNKObAx5kv68fSnqN+Qy/OfOWQne+Q6YD4OPNlGVjacVRp6GUxBy6LOZpRv4FPM1/21qUdZ/2GXpr5yhE73yBTLPBp5svqtLTjsNLQC2MOXBhzNMN+A59mvmz5SztO+w29NPOVI3a+QaZS4NPMl0Vzab95paGXxhy4NOZopv0GPs18WYmY9hv3G3pp5isH7Hx/TJnAp5lfT+USRjx+emHMgQtjjmbab+CzzJflkWm/cb+hl2W+crzO98e0CHyW+fVcEmFEd3oGgQtjjmbcb+CjzK/nEggjutOzB4mzB2ZUduCTzK+nkgcjmtMzB1wWczTTfgOfY349lTgY0ZyeNUicNTCDskPaMOUw01NnRHN6xmBt+upcc0xjwKeYX08lDEY0p2cLEmcLzJzskDbYgpmI4PDH7nz77Z+f9qvUwVjppdUKWgzsvhON6sRaTPNqJzbkk19msZa/7ic9OfrSxQWVRzOoPPBB5fEy2GidhOMmkWRm2s5M+4B0mdQyzslxjzinpqazybQVyJeZR+OYHPeI5DTTe2baDZTLmJZxTI57xNk1Nf1NphVBvcw7rp+S4xZxL3fUFKCZFgXtMqK1fkiOW8SJtmC6nEzrgrle8Iybdcw9a5C5tzzB/gaJtgZTXTEYN6GVe9Ytc/d0gil2Mm8T9DLouHpIjlpUuPc9wRSjhdYMU111GzeflXuXdQrnGILpGArtGCRexhxXD8lxizjDEEzDUGjDMNWV62HjWaXnFwrnF4LpFwrtF6a6cz1sxrH07ELh7EIw7UKh7cJcoz+jprNKzy0Uzi0E0y0U2i1MNfozasKx9MxC4cxCMM1Coc3CVCOoo2azSs8rFM4rRNMrFNorzDWBOmi8sfSkQuGkQjSlQqGlwlSrEAaNZpWeUSicUYimUSi0UZhqD8Kg2cbS0wmV0wnR1AmV1gkaLoNZpecSKucSoukSKu0SNF4mG2tPJFROJERTJFRaJEy1Gm7MXFbtWYTKWYRoWoRKW4SptsKNGWusPYVQOYUQTYVQaYUw14rSIXcTas8fVM4fRNMfVNofTLWcdMi1hNqTB5WTB9GUB5WWB9r2PpdVe+agcuYgmeag0uZgrh3ZQx48PW1QOW2QTG1QaW0wVWTDkMdOzxlUzhkk0xlU2hlMldQw5KnTEwaNEwbJFAaNH3MIOx/Mqj1b0DhbkExb0GhbMFUg0IiRRvZgmCagYcF6SwRT8RYfdhJsZX79bgGsRPBaCTR1skWwEuq1EmjIYEtgJcRrJdDcyZbBShycViKgMYMNy21eEp4cVgJNnmwVrET1Wgk0wro1sBLFayXAVPN4OICVyF4rkdBKCFiJ5LUSEa0EyJjqlTFDQSsBMqZ6ZcyQ0UqAjKleGTM0tBIgY6pXxgwVrQTImOqVMaOglQAZU7wyZjyglQAZU7ySVYTJCmRM8UrbEaTtKCBjilfGjChjCsiY4pUxI8qYAjKmeGXMiDKmgIwpXhkzoowpIGOKV8aMKGMKyJjilTEjypgCMqZ4ZcyEMqaAjOkVMROKmAIipleuSjBXgYTpFbUTitoKAqZXvkwoXyrIl17xMqF4qSBeeqXLhNKlom/JvRYChUvF4NJrHTL69FQMLb0ejIzilGJg6fUrZYafnRhWen10ZhSmFKNKryyV4ScnBpVe4TqjKBUwpvT63VZGn5sBQ0q3339nlKQChpRulUxGlUzAkNKtpcuopQsYUroVtwVlyoAxpVuXX1CoDBhUun29U1CqDBhVun3jV1CsDBhWun0dXlCuDBhXun0bXlCwjBhYur0qUlCyjBhZur09VFCyjBhZur1QVlCyjBhZur1jWFCyjBhZur12WlGyjBhZur2JXFGyjBhZur2cXlGyjBhZup1XqChZRows3Y6wVJQsI0aWbqeaKkqWCSNLt4NuFSXLhJGl29nHipJlwsjS7ThsRckyYWTpdkK6omSZwNfgXsmyoWSZMLJ0u0ehrZLld6+u7h5v3z193g9vP91+eLh7+qVeXf18+/Dx5fdewkFKaEFS+Pz5/wHZIHzS
      
  • 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! :)
Rseding91
Factorio Staff
Factorio Staff
Posts: 14338
Joined: Wed Jun 11, 2014 5:23 am
Contact:

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

Post 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 2896 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.
If you want to get ahold of me I'm almost always on Discord.
User avatar
DaveMcW
Smart Inserter
Smart Inserter
Posts: 3717
Joined: Tue May 13, 2014 11:06 am
Contact:

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

Post 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.
Twinsen
Factorio Staff
Factorio Staff
Posts: 1351
Joined: Tue Sep 23, 2014 7:10 am
Contact:

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

Post by Twinsen »

We are going for whatever C++ sets as standard, so it's indeed working as intended.
mrvn
Smart Inserter
Smart Inserter
Posts: 5881
Joined: Mon Sep 05, 2016 9:10 am
Contact:

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

Post 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.
User avatar
infinitysimplex
Burner Inserter
Burner Inserter
Posts: 14
Joined: Fri Jul 28, 2017 8:26 pm
Contact:

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

Post 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. :)
User avatar
DaveMcW
Smart Inserter
Smart Inserter
Posts: 3717
Joined: Tue May 13, 2014 11:06 am
Contact:

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

Post 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 2434 times
Post Reply

Return to “Not a bug”