rngs | Extra RNGsAll crates in this repository require Rustc | DevOps library

Well, depening on your data, you could try:

An example using rand_chacha::ChaCha8Rng:

Thank to the comments, I realized that my idea about containers being thread-safe was wrong (well they are safe to read but not to modify).

Assignments and call to push_back must be wrapped in

Computing a single-precision square root via double-precision code is going to be inefficient, especially if the hardware provides no native double-precision operations.

The following assumes hardware that conforms to IEEE-754 (2008), except that subnormals are not supported and flushed to zero. Fused-multiply add (FMA) is supported. It further assumes an ISO-C99 compiler that maps float to IEEE-754 binary32, and that maps the hardware's single-precision FMA instruction to the standard math function fmaf().

From a hardware starting approximation for the reciprocal square root with a maximum relative error of 2^-6.75 one can get to a reciprocal square root accurate to 1 single-precision ulp with two Newton-Raphson iterations. Multiplying this with the original argument provides an accurate estimate of the square root. The square of this approximation is subtracted from the orginal argument to compute the approximation error for the square root. This error is then used to apply a correction to the square root approximation, resulting in a correctly-rounded square root.

However, this straightforward algorithm breaks down for arguments that are very small due to underflow or overflow in intermediate computation, in particular when the underlying arithmetic operates in flash-to-zero mode that flushes subnormals to zero. For such arguments we can construct a slowpath code that scales the input towards unity, and scales back the result accordingly once the square root has been computed. Code for handling special operands such as zeros, infinities, NaNs, and negative arguments other than zero is also added to this slowpath code.

The NaN generated by the slowpath code for invalid operations should be adjusted to match the system's existing operations. For example, for x86-based systems this would be a special QNaN called INDEFINITE, with a bit pattern of 0xffc00000, while for a GPU running CUDA it would be the canonical single-precision NaN with a bit pattern of 0x7fffffff.

For performance reasons it may be useful to inline the fastpath code while making the slowpath code a called outlined subroutine. Single-precision math functions with a single argument should always be tested exhaustively against a "golden" reference implementation, which takes just minutes on modern hardware.

This code allows you to copy data from your spreadsheet, redact it, align each column independently and then post it in to SO with the appropriate markdown to make a nice looking table.

The Code:

redact.gs:

Is there a elegant implement of the Iterator for the Rc in Rust?

Not really. There's two big things in your way.

One limitation when building an Iterator is that the output type cannot reference the iterator itself. It can either return an owned value (no lifetimes involved) or return references bound to the lifetime of some other object.

I see you've tried to communicate that you want to return Refs bound to the lifetime of the orignal SkipList by using PhantomData<&'a K> and also using 'a in your Iterator::Item. However, since your iterator can only source values from ptr, an owned value with no lifetime-linkage to 'a, the compiler will complain about mismatched lifetimes at one point or another.

In order to do this, your iterator would have to use something bound to 'a, probably some form of Option<'a, _>>.

However, another limitation is when you have nested RefCells, with each level that you iterate, you need to keep around an additional Ref. The reason being that borrows from a Ref don't keep the lifetime of the RefCell, but from the Ref itself.

I have found a solution which involves using the OpenSSL crate to first make a hash of the N-length vector, then use the resulting hash as the random seed:

Usually when you get these confusing messages saying "trait bound not met" when it's clearly met, or "wrong type" when it's clearly the right type, you should always check package versions. As of right now (ed25519-dalek v1.0.1), it depends on rand 0.7.0 (you can also find this on crates.io). You're using a newer version of rand, with a "newer" version of the trait, and it's looking for the 0.7.0 trait while you supply the 0.8.0 trait.

The solution? Either downgrade rand to 0.7.0 or use dependency renaming to have 2 versions of rand, and use the old version for ec25519-dalek.