musl

Your general point stands, but with corrections: - sqrt actually can be a single instruction on x86_64 for example. Look at how musl implements it, it's just a single line inline asm statement, `__asm__ ("sqrtsd %1, %0" : "=x"(x) : "x"(x));`: https://github.com/ifduyue/musl/blob/master/src/math/x86_64/... Of course, not every x64_64 impl must use that instruction, and not every architecture must match Intel's implementation. I've never looked into it, but wouldn't be surprised if even Intel and AMD have some differences. - operator precedence is well-defined, and IEE754 compliant compilation modes respect the non-associativity. In most popular compilers, you need to pass specific flags to allow the compiler to change the associativity of operations (-ffast-math implies -funsafe-math-optimizations which implies -fassociative-math which act

This is a faster implementation of cosine that utilises six static const double variables (C1, C2, C3, C4, C5, C6) to speed things up. These variables represent the coefficients of a polynomial approximation for the cosine function. For the genuine article, check out: https://github.com/ifduyue/musl/blob/master/src/math/cos.c

Which is just a support function for cos (which doesn't do argument reduction). See [1] for the actual function, and [2] & [3] for the argument reduction code. [1] https://github.com/ifduyue/musl/blob/master/src/math/cos.c [2] https://github.com/ifduyue/musl/blob/master/src/math/__rem_p... [3] https://github.com/ifduyue/musl/blob/master/src/math/__rem_p...

For anyone else confused by this, the control logic described in the comment happens in https://github.com/ifduyue/musl/blob/master/src/math/cos.c

But am I correct in thinking that is at worst a 0.5 ulp error in this case? The lesser term in double-double can't be more than 0.5 ulp of the greater term and sensitivity of both sine and cosine to an error in the input will not be more than 1. Also, in case of confusion, I was specifically commenting on the function over the [-pi/4, pi/4] domain in https://github.com/ifduyue/musl/blob/master/src/math/__cos.c , which the comment in https://news.ycombinator.com/item?id=30846546 was presumably about.

It is a double-double representation [1], where a logical fp number is represented with a sum of two machine fp numbers x (head, larger) and y (tail, smaller). This effectively doubles the mantissa. In the context of musl this representation is produced from the range reduction process [2]. [1] https://en.wikipedia.org/wiki/Quadruple-precision_floating-p... [2] https://github.com/ifduyue/musl/blob/6d8a515796270eb6cec8a27...

Dead code elimination is incredibly important for (statically linked) libraries though, usually you don't use the entire feature set of a library, and you also don't want to have the unused features end up in the executable. Traditionally this was done by building libraries from many tiny object files (e.g. one source- and object-file per function: https://github.com/ifduyue/musl/tree/master/src/stdio) since linkers would only work on 'object file granularity' and libraries are simply a container for object files, but the more recent and more flexible DCE strategies allow the same optimzation without splitting the library source code into hundreds of small files.

Also, here's the source from musl (somewhat similar to what we have) https://github.com/ifduyue/musl/blob/79f653c6bc2881dd6855299...

It doesn’t — I was wrong. I was digging through its source code, and it turns out it isn’t memory-safe after all. Here’s the source code for stpcpy: https://github.com/ifduyue/musl/blob/master/src/string/stpcp... If dest is too small in the function linked to above, musl’s stpcpy will happy cause a buffer overflow. Don’t know how or from where I got the impression that musl was a “safer” alternative to libc.