Add missing long double math functions

[p00ya]

The libc.math module (cython/Cython/Includes/libc/math.pxd) seems to be missing a bunch of long double functions. For example, this will error:

from libc.math cimport expl

I wasn't sure if that was intentional for portability. There's a workaround to use the numpy.math equivalents (though one may not want a numpy dependency or the non-system implementation). If it's just an oversight, I can send a PR.

Tangentially related: I also considered a new module corresponding to C99's <tgmath.h>, which uses macros that expand into the appropriate function call depending on the type (e.g. exp(x) in C will call expl, exp, cexp or expf depending on the static type of x). If we did:

cdef extern from "<tgmath.h>" nogil:
  long double exp(long double x)

def foo(float x):
  cdef float y
  y = exp(x)

would that end up generating appropriate C to call expf via the macro, or would the Cython declaration cause an upcast to long double? I couldn't find documentation for what assumptions Cython makes about the types relating to extern'd macros.

[scoder]

I wasn't sure if that was intentional for portability.

.pxd declarations don't really have portability constraints. They only end up in C code if they are actually used in Cython code. PR welcome.

exp(x) in C will call expl, exp, cexp or expf depending on the static type of x

Cython can do this, too, at least internally (for C mode) and in C++ mode. We do this for Python's abs() function, for example. You can't currently declare overloaded C functions in user code, though. Could be worth adding this as a feature, although it might end up hiding accidental redeclaration bugs. Maybe an explicit '@cython.overload` decorator for such declarations could be used to silence the warning. Could actually be relatively easy to implement.

The issue with macros that allow for different return types is that Cython would not understand the logic and would use the (wrong) single declared return type in all cases. The normal way to deal with them is to give different Cython names to the same C macro and then call the right one in the Cython code, but that totally counters the idea of a joined dispatcher macro.