SR | SR

It looks like the issue is with the use of summarise() instead of mutate(); when you use summarise() you only keep the variable of interest, e.g.

so as @Chris Culter mentioned in a comment above, I just restarted my machine and it works again.

It is kind of strange because I already updated my Docker Desktop, restarted, and cleaned/ purged the docker data. None of those helped, just after restarting my windows it works again!

I rewrote your code with some better ways to create table. My idea was to pick out the buttons that fell onto a range of type and then loop through those buttons and change its color to those type.

try this

I assume, given when you posted this question, you are using LTS 18.17. Looking at that LTS, it uses mintty 0.1.3. Looking in mintty 0.1.3's cabal file shows a special flag that is enabled by default that means that System.Console.MinTTY.Win32 is not included. The comments in that cabal file say that that flag should be used when using Win32 2.13.1.0 or newer.

However, when I look at LTS 18's configuration in Stackage, I can see that it is using Win32 2.6.2.1, so that flag ought to be set to false for this package to work.

So let's check that in the Stackage build constraints. I see that another flag is being set, and it seems to be an old flag that is no longer used (looks like it was used in an older 0.1.2 version). This must be the problem.

The solution: manually set the flag in your stack.yaml:

I would like to know if release+acquire can violate happens-before.

Happens-before relationship cannot be "violated", as it is a guarantee. Meaning, if you established it in a correct way, it will be there, with all its implications (unless there is a bug in the compiler).

However, establishing just any happens-before relationship doesn't guarantee that you've avoided all possible race conditions. You need to establish carefully chosen relationships between relevant operations, that will eliminate all scenarios when data race is possible.

Let's review this code snippet:

I am focussing on _mie_S1_S2 since it appear to be the most expensive function on the provided example dataset.

First of all, you can use the parameter fastmath=True to the JIT to accelerate the computation if there is no values like +Inf, -Inf, -0 or NaN computed.

Then you can pre-compute some expensive expression containing divisions or implicit integer-to-float conversions. Note that (2 * n + 1) / n = 2 + 1/n and (n + 1) / n = 1 + 1/n. This can be useful to reduce the number of precomputed array but did not change the performance on my machine (this may change regarding the target architecture). Note also that such a precomputation have a slight impact on the result accuracy (most of the time negligible and sometime better than the reference implementation).

On my machine, this strategy make the code 4.5 times faster with fastmath=True and 2.8 times faster without.

The k-based loop can be parallelized using parallel=True and prange of Numba. However, this may not be always faster on all machines (especially the ones with a lot of cores) since the loop is pretty fast.

Here is the final code:

Question 1:

The margin-right actually is placing the slides on top of one another - it's the CSS transform that fixes this and makes the slides appear next to each other. Take a look at this example where the slides are forced to display: block and you'll see the third slide, with the other two stacked beneath.

The real reason for using margin-right: -100% is to make sure the slides appear in a row, rather than stacking vertically. See this example where the slides are visible and the negative margins removed - you can scroll down to see all the slides are stacked vertically.

Question 2:

So why does the slide on the right also get transformed? This one is a little tricky to debug, but what I think is happening is bootstrap is adding two classes to the right slide: carousel-item-next and carousel-item-left

If you look at the source CSS, carousel-item-next adds a transform: translateX(100%) to the element. But that CSS rule only includes the transform if the second class is not present: