gmp-wasm VS Random

I wondered about Drew's "antagonism" last year when he claimed that Google was DDoS'ing Sourcehut, which is why sr.ht blacklisted the Go module mirror; see https://news.ycombinator.com/item?id=34310674 .

I concluded he was right after I read about ongoing problems with the GMP project, at https://gmplib.org/ : "The GMP servers has been under serious load due to a barrage of clone requests from Microsoft/Github. ... In effect, Microsoft's computer cloud performed a DDoS attack on the GMP servers. ... Our servers are fully available again, but that's the result of us adding all participating Microsoft network ranges to our firewall. We understand that we are far from the first project to take such measures against Github."

Also, you can't build projects like Sourcehut by being only an antagonist, and I can think of some pretty antagonistic CEOs of billion dollar companies.

There are "bignum" implementations for every language. Though I never tested the performance impact on closed-form Fibonacci when a defined double precision >64bit is used.

https://gmplib.org/

Your code has an accidentally quadratic runtime (instead of linear). Since the array is appended to, the code regularly increases the memory region and has to move all the previous data over.

You could pre-allocate the memory as n is known ahead.

Different data types can take up varying amounts of memory. Take an integer as an example, this data type usually takes up 4 bytes of memory (DWORD in x86 architecture), while a floating-point data type can take up 8 bytes (or more, depending on what compiler you are using, on that offers a lot of flexibility is GMP)

I also disagree, and they were DDOS, so technically Microsoft broke a law.

>Granlund was not entirely satisfied with Blacker's explanation, nor the implied feebleness of the project's server(s)

So, every project needs to have a multi-million USD server Farm ? GMP is probably pulled by various Linux distros and the BSDs, along with other Misc projects. So no need for a huge server farm.

For people who do not know what it is:

https://gmplib.org/

The front page of https://gmplib.org/ has two other undated updates that the current server is too slow because of meltdown and they're going to replace with it with an epyc server in mid April.

Ive been trying to use the gmp library but I keep getting errors. Ive noticed that the last release was from 2020 and was wondering if there was any newer versions anywhere else. I'm currently running Fedora 38 and using VSC as my editor. This is the error I get:

You also left out GNU Smalltalk, whose PDF manual is 138 pages, and GMP, whose PDF manual is 152 pages.

If you are using the GCC, it was (probably) built with the GNU Multiple Precision Arithmetic Library. You just have to compile your program with the library specified like: g++ mycxxprog.cc -lgmpxx -lgmp where gmp is the GNU MP library and gmpxx contains the C++-specific functions.

Sure here is a an example (repository) (click "run" to see it work) contrasting the two in Rust, note that it is not fully symbolic, just the imaginary component. But the immediate advantage one can see is allowing direct computation without needing to modify the polynomial multiplication algorithm. (As noted in the source code, this is a purely theoretical advantage).

I can't help you with the specific website, but here's a trivial cli implementation of Game of Life.

I've been sitting on my hands when it comes to updating my library, but if you really want a fast test, you can use some of my research/implementation for RCPrime, with creditation of course. I'm not sure what algorithms FLINT uses, but I'm fairly certain that the RCPrime implementation is the most efficient for integers less than 2^35 (requiring 64 multiplications and only one strong fermat test) even if you implement with Montgomery exponentiation.

Here is a sample implementation along with the inverses of the first 128 primes (in hex). (Except 2, which can be easily checked by the &1 trick)

Not what one normally considers in CS, but producing a fast deterministic test for checking primality in the interval 0;2^64 with some extensions beyond. Fully constructing one to 2^128 is well beyond what is currently computable, however some progress has been made that surpasses published bounds.

Working on developing a faster and smaller primality check in the interval 0;2^64 with tentative extensions towards 2^65. While it performs satisfactorily for the intervals currently available, reducing the memory to less than other implementations is a major challenge.

See this other approach for a similar engine, that utilizes a linear bitvector to model cellular automata.

You are way overthinking it. For something like minesweeper you can just model an integer lattice, and use either a 1d vector of integers to represent the positions of the mines or a 1d bitvector and check the values in the chebyshev distance of 1 from the point. (If you use integers like in the first example, your system becomes a plane of 2^32, 2^32 dimensions and is bounded by the number of mines (64-bit integers) that can fit in your RAM)

You can look here for some slightly better ways to test for primality (ignore the different language).

RAND calls a hardware source of Johnson-Nyquist noise (basically electric static), and then performs some filtering on it to make sure that it's evenly distributed. There are faster methods, like a simple "linear" rng, but they frequently don't give as good results.