divergence | HTTP proxy that lets you map subdomains

Could use something like this:

You can try calculate the maximal total count for each week, then multiply that with the desired distribution. The idea is

1. Devide the Count by Desired Distribution to get the possible total
2. Calculate the minimal possible total for each week with groupby
3. Then multiply the possible totals with the Desired Distribution to get the sample numbers.

In code:

If your gradient function only has 5 components, it does not make sense to parallelize it in a way that one thread does one component. As you mentioned, GPU parallelization does not work if the mathematical structure of each components is different (multiple instructionsmultiple data, MIMD).

If you would need to compute the 5-dimensional gradient at 100k different coordinates however, then each thread would do all 5 components for each coordinate and parallelization would work efficiently.

In the backpropagation example, you have one gradient function with thousands of dimensions. In this case you would indeed parallelize the gradient function itself such that one thread computes one component of the gradient. However in this case all gradient components have the same mathematical structure (with different weighting factors in global memory), so branching is not required. Each gradient component is the same equation with different numbers (single instruction multiple data, SIMD). GPUs are designed to only handle SIMD; this is also why they are so energy efficient (~30TFLOPs @ 300W) compared to CPUs (which can do MIMD, ~2-3TFLOPs @ 150W).

Finally, note that backpropagation / neural nets are specifically designed to be SIMD. Not every new algorithm you come across can be parallelize in this manner.

Coming back to your 5-dimensional gradient example: There are ways to make it SIMD-compatible without branching. Specifically bit-maskimg: You would compute 2 cosines (for componet 1 express the sine through cosine) and one exponent and add all the terms up with a factor in front of each. The terms that you don't need, you multiply by a factor 0. Lastly, the factors are functions of the component ID. However as mentioned above, this only makes sense if you have many thousands to millions of dimensions.

Edit: here the SIMD-compatible version with bit masking:

Try

.updateOld() is a method, not a property (it needs parentheses).

I found this on the next link: Back Testing RSI Divergence Strategy on FX

The author of the post used the exponential moving average for RSI calculation, using this piece of code:

Ok, after massaging the equation for KL divergence a bit the following equation should work too and of course, it's magnitudes faster,

1. why are the values of phi and phi2 slightly different?

phi and phi2 are different because eq2 doesn't converge as rapidly as eq1. This is because eq1 is more implicit than eq2. If you change the tolerance for the residual, e.g., res > 1e-10, you'll see the two solutions are in much closer agreement.

1. how could I extract the outflow term for each cell (when a more complex grid will be used) while keeping 'ImplicitSourceTerm', which is more efficient?

You can still evaluate the flux phi2 * extCoef * phi2.faceGrad, even when you use the ImplicitSourceTerm.

In general, it's not easy to extract what each Term is doing physically (see issue #461). You can use the FIPY_DISPLAY_MATRIX environment variable to see how each Term contributes to the solution matrix, but this may or may not give you much physical intuition for what's going on.