covariance | Computes the covariance between one or more arrays | Dataset library

How does the assignment inside the unsafe block affect the lifetime inference for the parameters of set()?

It doesn't — and this is not even specific to raw pointers or unsafe. Function bodies never affect any aspect of the function signature (except for async fns which are irrelevant here).

Raw pointers does not have lifetime then how does the compiler know it should make cell and new_value have the same lifetime using covariance?

It sounds like you misread some advice. In the code you have, Cell is invariant in T, but for an interior-mutable type to be sound, it must be invariant (not covariant) in the type parameter. In the code you have, the compiler infers covariance for T because MyCell contains a field that is simply of the type T. Covariance is the “typical” case for most generic types.

Therefore, the code you have is unsound because MyCell is covariant over T but must instead be invariant over T.

Your code is also unsound because in the implementation of set(), you're creating an immutable reference to a T, &self.value, and then writing to its referent. This is “undefined behavior” no matter how you do it, because creating &self.value asserts to the compiler/optimizer that the pointed-to memory won't be modified until the reference is dropped.

If you want to reimplement the standard library's Cell, you must do it like the standard library does, with the UnsafeCell primitive:

veganCovEllipse is not an exported function. This means that it is not intended for interactive use, but it is a support function only to be called from other functions in vegan. Therefore it is not documented. However, the answer is simple: it can calculate any kind of ellipse depending on the input. In vegan the function is called for instance from ordiellipse and there it can draw standard error ellipses, "confidence" ellipses (standard error multiplied by some value picked from statistical distribution), standard deviation ellipses, standard deviation ellipses multiplied by similar constants as standard errors, or enclosing ellipses that contain all points of a group, depending on the input to the function. In showvarparts function it is just re-used to draw circles. Actually veganCovEllipse does not fit anything: it just calculates the coordinates to draw what you asked it to draw, and your input defines the shape, size, orientation and location of the ellipse coordinates.

There are other functions in other packages that do the same: return you the points needed to plot an ellipse from your input data. For instance, the standard (recommended) package cluster makes similar calculations in non-exported functions cluster:::ellipsoidPoints with effectively the same mathematics, but in completely different way. This function is non-exported as well, and it is intended to be called from user function cluster::predict.ellipsoid. The vegan implementation is similar as in the ellipse function in the car package, where these calculations are embedded in that function and cannot be called separately from car::ellipse.

To be honest I don't think this will make your final result vary as much as to be consider not useful. Moreover, if you take a look at the warning, which is pretty accurate given the package you are using, it's only talking about 1 engine value over N2 that you are using.

Also, if you take a look at this post:

https://stats.stackexchange.com/questions/219302/singularity-issues-in-gaussian-mixture-model

You will find a good explanation on the second comment of the winning answer. There you understand why the variance/covariance cannot be 0. In you particular case, the value is close to 0 and that is why you are getting a warning.

If you just want to get rid of the warning, one possibility would be scaling and the other normalizing. That is totally up to you. when normalizing I would suggest a wide range, not 0...1 because you can face the same problem again.

Here are some code examples where I loaded your data in a variable called a:

I think using a multidimensional array is a very good idea in this case.

First, you can get the simulations of example_sim() much cheaper using mapply(). Here an example with time=10 and npops=3. Use the same set.seed(42) and parameters and check for yourself.

I use much smaller parameters here so that you can easily check the result in your head.

You could directly copy the segments_fit implementation

It's not so very obvious on how to use these libraries (but that's complex math, so this is actually expected...)

You can print the contents of a matrix like so:

The error message you are receiving is about trying to set a complex value in a dtype=float matrix. You would get the same error from:

In my real use-case, I need to apply the same constraint to multiple timesteps in a trajectory, so I think it would be helpful to create the symbolic function once when I call AddConstraint for the first timestep and then all subsequent timesteps shouldn't have to re-create the symbolic function, I can just use the cached version and apply it to the relevant variables. The expression involves a Cholesky decomposition of a covariance matrix so there are a lot of constraints being applied.

I would strongly encourage to write this constraint using a function evaluation, instead of a symbolic expression. One example is that if you want to impose the constraint lb <= my_evaluator(x) <= ub, then you can call it this way

Frankly I don't know how to implement what you are looking for. However, there is a easy workaround with minimal syntax. The idea is you await GetBAsync convert B to A, wrap A in a task and then return it. It is a extra-step, but a simple one: