particles | A Particle Dream | Game Engine library

this an issue with typescript version and for me details you can take a look at here :

https://github.com/matteobruni/tsparticles/issues/3853

I found the answer and have used Python for legibility.

View A is 1270*680.

TL;DR: np.fromfile and np.frombuffer are not optimized to read many small buffers. You can load the whole file in a big buffer and then decode it very efficiently using Numba.

The main issue is that the benchmark measure overheads. Indeed, it perform a lot of system/C calls that are very inefficient. For example, on the 24 MiB file, the while loops calls 601_214 times np.fromfile and np.frombuffer. The timing on my machine are 10.5s for read_binary_npfromfile and 1.2s for read_binary_npfrombuffer. This means respectively 17.4 us and 2.0 us per call for the two function. Such timing per call are relatively reasonable considering Numpy is not designed to efficiently operate on very small arrays (it needs to perform many checks, call some functions, wrap/unwrap CPython types, allocate some objects, etc.). The overhead of these functions can change from one version to another and unless it becomes huge, this is not a bug. The addition of new features to Numpy and CPython often impact overheads and this appear to be the case here (eg. buffering interface). The point is that it is not really a problem because there is a way to use a different approach that is much much faster (as it does not pay huge overheads).

The main solution to write a fast implementation is to read the whole file once in a big byte buffer and then decode it using np.view. That being said, this is a bit tricky because of data alignment and the fact that nearly all Numpy function needs to be prohibited in the while loop due to their overhead. Here is an example:

IIUC, you could use a custom function to find the height/width of the bounding box and compute the average of both dimensions:

I would load the system from the TPR file to maintain the bond information. Then MDAnalysis can determine fragments (namely, your proteins). Then loop over the fragments to determine the COM time series:

Alpha test is a (since ages deprecated) method to only draw fragments when they match some alpha function. Nowadays this can easily be done inside a shader by just discarding the fragments. Alpha testing in itself is also very limited, because it can only decide to draw a fragment or not.

In general, enabling GL_ALPHA_TEST without setting a proper glAlphaFunc will do nothing since the default comparison function is GL_ALWAYS which means that all fragments will pass the test.

Your code doesn't seem to rely on alpha testing, but on blending (I assume that since you are setting the glBlendFunc). Somewhere in your code there's probably also a glEnable(GL_BLEND).

C++ Copy Constructors: must I spell out all member variables in the initializer list?

Yes, if you write a user defined copy constructor, then you must write an initialiser for every sub object - unless you wish to default initialise them, in which case you don't need any initialiser - or if you can use a default member initialiser.

the object contains some member variables which are pointers to its other member variables)

This is a design that should be avoided when possible. Not only does this force you to define custom copy and move assignment operators and constructors, but it is often unnecessarily inefficient.

But, in case that is necessary for some reason - or custom special member functions are needed for any other reason - you can achieve clean code by combining the normally copying parts into a separate dummy class. That way the the user defined constructor has only one sub object to initialise.

Like this:

You could return a boxed iterator, so in case your implementation changes, the return type wouldn't need to:

There is Suppressor.jl, although I don't know whether this reduces the overhead you get from the warnings being created, so a DiffEq-specific setting might be the better way to go here (I don't know much about DiffEq though, sorry!)

Here's an example from the readme: