fathom | Fathom.js - Present JavaScript in its native environment

So the problem was that my function was receiving testId directly from the object test, as test.id.

This id, even if it's displayed as a string in the console.log, internally it's an object, so nothing was comparing correctly because of this.

When I changed test.id with "${test.id}" everything worked.

I'll proceed to kill myself now, thank you.

Thanks for your comments and suggestions! I ended up figuring out what was going on.

So for some reason, Django won't create a new CSRF cookie (even if it has been expired/deleted) if the session cookie is still valid. This seems like a bug, but maybe there's a security reason for it.

In my case, I had extended SESSION_COOKIE_AGE to 60 * 60 * 24 * 365 * 10, or 10 years. It turns out the default value for CSRF_COOKIE_AGE is 1 year. As such, everyone that had been logged in for a year no longer had a valid CSRF cookie, and Django wouldn't issue them a new one because their session was still valid for another 9 years.

Assuming you have tasks like:

This question is very vague, therefore so is the answer.

The most important point: there is no way to guarantee that OptaPlanner will find any particular solution, good or bad. If we knew how to reach into the search space and pull out a solution, we would not need OptaPlanner in the first place.

That "magic" under the hood that you mention is randomness. Unless you use REPRODUCIBLE environment mode (or the assert modes when not in production), OptaPlanner will never take the same path through the myriad possible solutions. OptaPlanner has no way of knowing if a better solution is just around the corner. It will simply try a random change, and see what happens. And it will use some smart heuristics to guess which is the best way to go from there.

OptaPlanner's way through the search space will be largely random, only guided by the constraints. And you need to take care and design your constraints very carefully. Most important in my opinion is to make sure you do not introduce score traps. A score trap is a situation where two vastly different solutions result in the same score. If the scores are the same, then the solutions are considered to be of equivalent quality. If you, as a human, can see that two solutions are qualitatively different yet their scores are the same, I suggest you figure out how to convert your insight into a constraint.

Once your constraints describe your problem as best as can be, the next goal is performance of the scoring function. OptaPlanner will find good solutions, assuming it has enough time to search. One way is to give it hours or days. Another way is to speed up the scoring function. This is a major topic on its own, and it is not really possible to give advice here without knowing the specifics of the problem. One general guideline: if your average score calculation count is on the order of hundreds or lower thousands per second, you have some work to do to help OptaPlanner help you. The more random changes you can process per second, the bigger your chance is of finding a good solution given the same amount of computation time.

And lastly, I am going to touch on your point of the input order. Yes, every time you change the input order, OptaPlanner will give different results. Even if you choose the REPRODUCIBLE environment mode - because your problem is suddenly different due to the input order. To avoid that, you should either make your order consistent, or you should look into planning entity difficulty and planning value strength to do the same for you.

EDIT: It is a downside of OptaPlanner that, on small data sets, we can (due to the nature of randomness) miss seemingly obvious good solutions, and a human would spot that. On these small data sets, using brute force is an obvious way to go - see branch and bound for example. But as the data sets grow larger, this will not scale and OptaPlanner's local search will significantly outperform anything any human can do. That is where OptaPlanner shines, and that is where it should be used.

You're trying to call .alpha on the function itemOneDelete. What you probably want instead is:

Here is a completely vectorized way to do this. It is very efficient and fast: 130 ms on a 1000 x 1000 matrix. This is a good opportunity to expose some interesting techniques using numpy.

First, let's dig a bit into the requirements, specifically what exactly the value for each cell needs to be.

The example given is [nan, nan, nan, nan, 4.0] --> [.66, .72, .79, .87, .96], which is explained to be a "progressively increasing value of 10%" (in such a way that the total is the "value to spread": 4.0).

This is a geometric series with rate r = 1 + 0.1: [r^1, r^2, r^3, ...] and then normalized to sum to 1. For example:

Look closer at the doc:

The targets are expected to be {0, 1} and not -1.
I'm not sure what this -1 is doing, it might be for "ignore", but you are correct that the doc there is not very clear.

There is an open issue on pytorch's github about this. Feel free to contribute.

Are you update your relations in database ? Maybe you should refresh your migrations on production server.

If you're using a model other than Laravel's supplied App\Models\User model, you'll need to publish and alter the Cashier migrations provided to match your alternative model's table name.

Another possible problem is that you have not set up a proper model for the auth.