oxxoxoxooo

Chubby chair (2012) - https://www.kooij.com/chubby

Hi! Congratulation on the launch, I hope the users will like these!

Please, I do have a question about Desktop: there have been numerous reports of noisy PSU fan and little feedback from FW [1], could you shed some light on the situation? Are you seeing noisy PSU yourself, are there plans for a fix or another PSU? I understand you wanted a separate, and thus reparable Flex ATX PSU, but maybe just one larger fan for the whole case would have worked better (c.f. Steam Machine)?

[1] https://community.frame.work/t/noisy-psu-fan/74751

Thanks!

On x86, there is no vector instruction to get the upper half of integer product (64-bits x 64-bits). ARM SVE2 and RISC-V RVV have one, x86 unfortunately does not (and probably wont for a long time as AVX10 does not add it, either).

Do you happen to know how does one access/use those A100 cores?

If you ever wondered, how Arduino came about: The Untold History of Arduino (https://arduinohistory.github.io/).

Thank you very much for the answers, very informative!

And congratulations on the discovery!

Hi! Please, I also have a few questions:

1. I guess the most time consuming part is multiplication, right? What kind of FFT do you use? Schönhage-Strassen, multi-prime NTT, ..? Is it implemented via floating-point numbers or integers?

2. Not sure if you encountered this, but do you have any advice for small mulmod (multiplication reduced by prime modulus)? By small I mean machine-word size (i.e. preferably 64-bits).

3. For larger modulus, what do you use? Is it worth precomputing the inverse by, say, Newton iteration or is it faster to use asymptotically slower algorithms? Do you use Montgomery representation?

4. Does the code use any kind of GCD? What algorithm did you choose?

5. Now this is a bit broad question, but could you perhaps compare the traditional algorithms implemented sequentially (e.g. GMP) and algorithm suitable to run on GPUs? I mean, does it make sense to use, say, a quadratic algorithm amenable to parallel execution, rather than a asymptotically faster (and sequential) algorithm?

Thanks for the reply! If you don't mind asking more: what do you use for polynomial GCD? Apparently it is quite fast, do you use some standard algorithm implemented well or is there some kind of algorithmic improvement? Is it described somewhere, say a paper or a book? Have you tried to benchmark it against NTL, for example? Thanks again!

Please, what do you use for bigints? GMP?

Prior art:

Binarized Neural Networks: Training Deep Neural Networks with Weights and Activations Constrained to +1 or -1

https://arxiv.org/abs/1602.02830

Ternary Neural Networks for Resource-Efficient AI Applications

https://arxiv.org/abs/1609.00222

True. Except, it's trivial to mitigate this: one only needs to wrap the whole library under one giant #ifndef. Like here, for example: https://github.com/sheredom/utf8.h/blob/b7ed0a28eb92803c81d6...

Thanks!

> Implementations of big number math can and does contain bugs. (I used to hunt for those via fuzzing, which turned up an amazing number of them.)

I'm curious, can you give some examples what kind of bugs did you discover?

And another one:

The Genuine Sieve of Eratosthenes https://www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf

> This instruction is used in some bignum code

Could you be more specific? I think for that to work one would also need the upper half of 64x64 multiplication and `vpmullq` provides only the lower half. You could break one 64x64 multiplication into four 32x32 multiplications (i.e. emulate the full 64x64 = 128 bits multiplication) but I was under the impression that this was slow.

Hi fish,

thanks for very interesting article, again!

Do you think the very fast division on M1 has any implications for 128/64 narrowing division as well? Do you know of a faster way than the method by Moller and Granlund? Do you plan on to include 128/64 division in libdivide?

And I asked this question before but the parent post got flagged so I'm trying once more: at the very bottom of the Labor of Division (Episode V) post [1], is it really possible for the second `qhat` (i.e. `q0`) to be off by 2? Do you have any examples of that?

[1] https://ridiculousfish.com/blog/posts/labor-of-division-epis...

I think that I shall never envision

An op unlovely as division

An op whose answer must be guessed

And then, through multiply, assessed;

An op for which we dearly pay,

In cycles wasted every day.

Division code is often hairy;

Long division's downright scary.

The proofs can overtax your brain,

The ceiling and floor may drive you insane.

Good code to divide takes a Knuthian hero

But even God can't divide by zero!

-- Henry S. Warren Jr.

Hacker's Delight

At the very bottom of the subsequent post [1], is it really possible for the second `qhat` (i.e. `q0`) to be off by 2? Any examples of that?

[1] https://ridiculousfish.com/blog/posts/labor-of-division-epis...

Not sure why this gets down voted, it is the correct definition of "telephoto" (i.e. "the physical length of the lens is shorter than the focal length").

Thank you for the reply! Could you be more specific? In the case of 1D FFT, the right half (possibly zero-padded) of the signal is completely mixed up with the left half after the first pass [of breath-first FFT]. If the right half was all zeros, would it still be twice as fast in 1D case? Do you have any pointers to literature which discusses this?

What is "Native zero padding to model open systems"? And how come it is "up to 2x faster than simply padding input array with zeros"?

If you are into integer sorting, this might be of interest as well:

https://yourbasic.org/algorithms/fastest-sorting-algorithm/

https://sorting.cr.yp.to/

Josh, Gerben!

Have you tried a sorting network, instead of the bubble sort?