From Paul Zimmermann on 9 September 2024:
Implement mpc_cbrt.

From Thomas Henlich on 20 February 2020:
Implement the cotangent function.

From Joseph Myers 12 Apr 2015:
https://sympa.inria.fr/sympa/arc/mpc-discuss/2015-04/msg00009.html
Try implementing tan z = (sin 2x + i sinh 2y) / (cos 2x + cosh 2y) or
(sin(x)*cos(x) + i*sinh(y)*cosh(y))/(cos(x)^2 + sinh(y)^2) as in glibc.

From Karim Belabas 9 Jan 2014:
Implement Hurwitz(s,x) -> gives Zeta for x=1.
Cf http://arxiv.org/abs/1309.2877

From Andreas Enge 27 August 2012:
Implement im(atan(x+i*y)) as
1/4 * [log1p (4y / (x^2 +(1-y)^2))]
(see https://sympa.inria.fr/sympa/arc/mpc-discuss/2012-08/msg00002.html)

From Andreas Enge 23 July 2012:
go through tests and move them to the data files if possible
(see, for instance, tcos.c)

From Andreas Enge 31 August 2011:
implement mul_karatsuba with three multiplications at precision around p,
instead of two at precision 2*p and one at precision p
requires analysis of error propagation

From Andreas Enge 1 December 2022:
think about, implement and document the possibility of having signed
zeros as real and imaginary parts of results of multiplication.
We might follow IEEE 754-2019, 3rd paragraph from section 6.3:

   "When the sum of two operands with opposite signs (or the difference of two
   operands with like signs) is exactly zero, the sign of that sum (or
   difference) shall be +0 under all rounding-direction attributes except
   roundTowardNegative; under that attribute, the sign of an exact zero sum
   (or difference) shall be -0. However, under all rounding-direction
   attributes, when x is zero, x + x and x - (-x) have the sign of x."

From Andreas Enge and Paul Zimmermann 6 July 2012:
Improve speed of Im (atan) for x+i*y with small y, for instance by using
the Taylor series directly. See also the discussion
https://sympa.inria.fr/sympa/arc/mpc-discuss/2012-08/msg00002.html
and the timing program on
https://sympa.inria.fr/sympa/arc/mpc-discuss/2013-08/msg00005.html

For example with Sage 5.11:
sage: %timeit atan(MPComplexField()(1,1))
10000 loops, best of 3: 42.2 us per loop
sage: %timeit atan(MPComplexField()(1,1e-1000))
100 loops, best of 3: 5.29 ms per loop

Same for asin:
sage: %timeit asin(MPComplexField()(1,1))      
10000 loops, best of 3: 83.7 us per loop
sage: %timeit asin(MPComplexField()(1,1e-1000))
100 loops, best of 3: 17 ms per loop
-> should be much faster with revision 1402 (check)

Same for acos:
sage: %timeit acos(MPComplexField()(1,1))      
10000 loops, best of 3: 90.8 us per loop
sage: %timeit acos(MPComplexField()(1,1e-1000))
1 loops, best of 3: 2.29 s per loop

Same for asinh:
sage: %timeit asinh(MPComplexField()(1,1))     
10000 loops, best of 3: 84 us per loop
sage: %timeit asinh(MPComplexField()(1,1e-1000))
100 loops, best of 3: 2.1 ms per loop

sage: %timeit acosh(MPComplexField()(1,1))      
10000 loops, best of 3: 92 us per loop
sage: %timeit acosh(MPComplexField()(1,1e-1000))
1 loops, best of 3: 2.28 s per loop

From Andreas Enge and Sergey B Kirpichev 1 March 2026:
The current implementation of mpc_fr_div differs from mpc_div in essentially
one line - the multiplication b*conj(c) needs to call a function that depends
on the type of b.  It is annoying to have to copy rather complex code with
overflow handling and so on instead of just being able to call the already
existing function.
https://sympa.inria.fr/sympa/arc/mpc-discuss/2026-02/msg00031.html

Bench:
- from Andreas Enge 9 June 2009:
  Scripts and web page comparing timings with different systems,
  as done for mpfr at http://www.mpfr.org/mpfr-2.4.0/timings.html

New functions to implement:
- from Joseph S. Myers <joseph at codesourcery dot com> 19 Mar 2012: mpc_erf,
  mpc_erfc, mpc_exp2, mpc_expm1, mpc_log1p, mpc_log2, mpc_lgamma, mpc_tgamma
  https://sympa.inria.fr/sympa/arc/mpc-discuss/2012-03/msg00009.html
  See the article by Pascal Molin (hal.archives-ouvertes.fr/hal-00580855).
- implement a root-finding algorithm using the Durand-Kerner method
  (cf http://en.wikipedia.org/wiki/Durand%E2%80%93Kerner_method).
  See also the CEVAL algorithm from Yap and Sagraloff:
  http://www.mpi-inf.mpg.de/~msagralo/ceval.pdf
  A good starting point for the Durand-Kerner and Aberth methods is the
  paper by Dario Bini "Numerical computation of polynomial zeros by means of
  Aberth's method", Numerical Algorithms 13 (1996), 179-200.

New tests to add:
- from Andreas Enge and Philippe Théveny 9 April 2008
  correct handling of Nan and infinities in the case of
  intermediate overflows while the result may fit (we need special code)
