orbit | C/C++ Performance Profiler | Monitoring library

You're going to have to start by translating the the orbit into a rotation rate, which will give you an equation for θ(t), where t and θ(t) is the angle (normally in radians) in the orbit at time t. The position would then be given by

You can add a time factor variable. This would require you to change some things about time management:

• Restart the clock each frame and acumulate the time in a separate variable.
• Have a new variable with the time factor, that multiplies the delta time each frame.

You need to put your component in a because it needs to load a texture so the way to do it is to wait for it to load using suspense.

You can specify an object to show while it is loading by doing

param has shape (len(T), len(Y)), so time is in the first dimension and the x,y,z are in the second dimension. You will get the correct plot with

I changed all my es6 classes into es6 modules, and used import. I don't think there was a solution for this with cdn or raw git scripts.

This is probably due to the step size control being also influenced by the rapidly growing v vector. Either by regulating step sizes rapidly down due to stiffness, or more likely, due to increasing the step size to match the dominant components, thus becoming unsuitable for an exact integration of the original trajectory. This rapid growth is the reason that Lyapunov exponents were introduced, as they capture this growth in nicely bounded numbers.

What you can do is to split up the integration into smaller chunks and normalize the v vector at the start of each chunk. One would have to experiment on how long it takes until the v component unduly dominates the step size control. As the coupling is purely multiplicative, the dynamic theoretically is linear. So it could also help if you scale the initial v to have norm 1e-100.

First however check what error tolerances you use. Setting them narrower also tends to stabilize the computation. You might also get some progress be setting the maximal step size hmax to half or so of the external step.

Or you could do the Lyapunov exponent computation like I explored in https://scicomp.stackexchange.com/questions/36013/numerical-computation-of-lyapunov-exponent. This approach however increases a system of dimension n by the n x n matrix of eigen/singular vectors and the n products of exponents times time.

I think the issue is with your AnimationMixer.update() call. If you look at the docs, update is expecting a time-delta in seconds, but it looks like you're passing the total running time. This means it should receive the time passed since the last frame. You can fix this by using clock.getDelta(); as the argument:

I eventually figured out how to do it after a good night of sleep, here is a working version that uses the B1-Motion and ButtonRelease events instead of updating everytime one slider is moved because it would execute the command twice by just moving one slider. This led to the value being used for the calculation not being the current one because of how things are processed.

OK well I figured it out. AniMarker which takes the Set of animated Markers, is final. So once you hand it the set of say RippleMarkers, it'll animate them, but you can't then turn it off via a SetState() call.

I tried editing the AniMarker class, to make it not final, so you could mutate it's dataset, but I think because it's built on GoogleMap's Marker class, and they're final, it just will not work.

So AniMarker presently has limited utility.

My work around was just to mutate GoogleMaps marker: option, so I could highlight a Marker by changing it's color. It's also possible to change the circles: GoogleMap option to dyanically highlight a Marker according to user interaction.