I'm just going gung-ho on the posit number operations.
I’ve been trying to implement a posit number square root function (for FPGA hardware) and it works for even exponent sizes but not for odd sizes. It has me stumped at the moment. It appears to be the size of the exponent, not the value that is causing issues.

For es = 6:

For es = 5 (same numbers) exponent appears to be off by one, significand looks okay
I'm comparing the square of the calculated root to the input.

Rob:

I am interested in your successes with posits. When you're finished, will you be posting / releasing some information on their implementation.

Read your comment on issue you're having with odd-sized exponent fields and computing the square roots for such posits. In the short run, why not reformat the posit into one with an even length square root? I would think that one of the fundamental components of your posit library would be format conversions, especially to support addition / subtraction.

Okay, I have put some code for posit arithmetic in Github under cores/thor/trunk/thor2020/v3/rtl//fpu. The same code is also available in opencores.org under the Float816 floating-point accelerator project.
Much of this work is based on the PACoGEN project in github. A good site for posits: posithub.org

I put code in to shift the number by a bit if es is odd and that seems to work, but it probably is just masking a greater issue.

Currently implemented:
intToPosit
fpToPosit
positTofp
positAddsub
positMul
positSqrt

no divide yet.

Thanks for the link. Haven't had time to fully delve into the paper or your code.

However, one thing that I found intriguing was that, within what appeared to be a somewhat reasonable approximation, inversion (1/x) was somewhat easy to achieve. If that's the case, what's to prevent you from implementing division as inversion followed by multiplication.

That is the approach that I used to implement fixed point division. I used the Goldschmidt square root algorithm which computes both the square root and the inverse of the square root. Since I needed the square root to solve the law of cosines, and I only needed to perform a division once per computational cycle, I used the square of the inverse of the square root followed by multiplication to implement that division operation that I needed. (The quantity for which I was computing the square root was always positive and non-zero.)