Tau | GTK frontend for the xi text editor , written in Rust | Editor library

The problem comes from the fact that the operation is not numerically stable. As a result it quickly diverge (exponentially) to 0 or infinity even with relatively-small values of n like 70. You can use a diagonalization method based on eigenvalues (see here for more informations) which is far more numerically stable.

You would find the value of scalar_delta for which example_data_missingdatacdf(x1,x2,x3,scalar_delta) - tau = 0. Assuming the function is monotonously increasing, this is the smallest value that satisfies your requirement.

There are standard numerical techniques to find the zero crossing of a function. MATLAB implements such a technique in fzero.

This is how you’d use it:

The function map in the package {purrr} is very useful for these situations.

The following bit iterates through each row in your df and feeds the values for each of the columns to your function (.x goes from 1 to the number of rows in df one by one. You can assign a value to .x to test that specific row; for example, .x = 1).

In your stopSpinning we could just remove the item that it landed on, we do that with:
.splice(getIndex(),1)
if you never use it before, read more here:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice

I also had to do a few more changes to accomodate the fact that now the array changes, for example the const numOfFruits = fruits.length instead of using that we just use the length directly when we need it

Try this code below:

EDIT

If you paste the greek letters with unicode, it should work.
Example, for alpha (upper case) and tau (lower case), it is

The documentation states, that the corner radius is applied to both ends of the arc. Additionally, you want the arcs to overlap, which is also not the case.

You can add the one-sided rounded corners the following way:

1. Use arcs arc with no corner radius for the data.
2. Add additional path objects corner just for the rounded corner. These need to be shifted to the end of each arc.
3. Since corner has rounded corners on both sides, add a clipPath that clips half of this arc. The clipPath contains a path for every corner. This is essential for arcs smaller than two times the length of the rounded corners.
4. raise all elements of corner to the front and then sort them descending by index, so that they overlap the right way.

Without having the full code to test outputs this is harder to do, but it seems that there are some redundant processes that you are adding elements to a list of lists only to flatten that list and add that to a dictionary as a set. You can increase some of the speed and memory by removing that and instead just adding it to the dictionary right away.

There are some other tweaks that can be done such as using f-strings instead of string concatenation, using list comprehension, and removing having to do the same math in the loop (time_range * gamma) and instead just reference it by memory.

But these are all minor tweaks compared to your step one process which looks to be the largest time sink (approx N^4 in time complexity). I am unsure if it is larger as I don't see the functions that you use inside that for loop, but tweaking that to reduce the number of calculations would provide the largest benefit to time savings.

So here's my solution to find the intersection of points that pass from above to below an arbitrary hyperplane. In my code, after I have created the taken matrix, here's my new implementation:

For a solution that works equally well for flat arrays of Lorentz vectors as for jagged arrays of Lorentz vectors, try this: