On multiple occasions I’ve seen noticeable accumulated rounding error crop up by the end of a cumprod over very long timeseries of floats.
But in my cases it has just been a minor nuisance that I have to double check whether a mismatch came from float-related quirkiness or a code mistake.
I got into the habit of just using integers where applicable for cases that need to match down to the last bit, and numpy.isclose() for inherently floaty cases where it’s anticipated and reasonable.
Only speaking from my own experience, which doesn’t involve chaotic systems or anything like that. I’m curious to hear from people in other domains who may have more exciting stories.
This is a really neat idea! I never thought about taking emissions into account when provisioning infrastructure. Only a small subset of my cloud workload is performance sensitive. For the majority of tasks (tests, background ETL processing, etc) I wouldn't even notice small latency increases.
My guess is that it's possible to prove that each side can force a draw. Just exchange the queens until there are too few that you are back in a normal chess game.
I'm not sure if I'm underestimating the number of possible moves, that is huge, but I hope not sooooooooo huge.
Interesting. Hmmm, I have to think this through. I believe that if the game followed normal chess rules, except for replacing the pieces with queens, then games where the captures are all even trades would result in draws, but if one side could come out ahead with K+Q vs K, then there would be the usual mate sequence.
HOWEVER the rule OP added that "a piece may only move if it is adjacent to another piece of either color" slightly complicates the endgame. My normal tendency would be to put the queen far away from the action to avoid blundering it, but here that would instantly deactivate it. It's kind of funny to picture the kings racing across the board to capture or reactivate the last inert queen.
I think one can still get the usual style of mate in this variant, you just have to walk the king and queen together, and pay extra attention to avoiding stalemate. For example, imagining white king on e1, black king on e3, black queen on d3. If white to move then Qb1# or Qe2#, fairly standard maneuvers (though if black to move that's a stalemate).
This is an interesting modification to the game, I'd play a few rounds...
> It's kind of funny to picture the kings racing across the board to capture or reactivate the last inert queen.
That would never happen. Because of the “of either color” clause, a king can’t even move to a square adjacent to a queen of the other color, as that activates the queen, moving the king into check.
Also, if the kings are included in the “piece” category of “a piece may only move if it is adjacent to another piece of either color” (which, I think/guess the OP didn’t consider), a lone king cannot race across the board.
I could see an endgame where the last exchange leaves all the remaining pieces isolated from each other. By the rules, then, no piece on either side can move. Stalemate? Or a flaw in the rules?
My guess/intuition is that the first player to move can win. I see two strategies that may work:
- use your queens ‘from the outside in’ to give check, forcing your opponent to take the queen giving check. In the long run, isolate an enemy queen in a corner, effectively removing it from play and giving you a surplus queen. Then, keep exchanging queens.
- use your queens to give check, forcing the queens near the enemy king to take them. Once the enemy king is isolated, it cannot move anymore, so giving check becomes dangerous. Black will have to either take the queen giving check or move a queen into the line of sight.
I use a few different distros on a routine basis. Out of those, Ubuntu would probably be the best fit - it generally works right out of the box, the UI is intuitive for day-to-day use, there's plenty of information online about how to install/use/troubleshoot it, and the App center has an open source alternative for anything and everything. Mint might also be a good fit - I had a very positive experience last time I used it, but that was a few years ago so I haven't tried the newer releases.
> I suspect what's happening is they've got some rule against the word "spectrum" or something
I've avoided this by using only the first few and/or last few letters of the service in the email tag (e.g. "HaNe" instead of "hackernews"). It's an easy filing system for me, doesn't trigger concerns about phishing, and makes for shorter handles.
On multiple occasions I’ve seen noticeable accumulated rounding error crop up by the end of a cumprod over very long timeseries of floats.
But in my cases it has just been a minor nuisance that I have to double check whether a mismatch came from float-related quirkiness or a code mistake.
I got into the habit of just using integers where applicable for cases that need to match down to the last bit, and numpy.isclose() for inherently floaty cases where it’s anticipated and reasonable.
Only speaking from my own experience, which doesn’t involve chaotic systems or anything like that. I’m curious to hear from people in other domains who may have more exciting stories.