csqrt, csqrtf,
    csqrtl — complex square root
    functions
#include
    <complex.h>
double complex
  
  csqrt(double
    complex z);
float complex
  
  csqrtf(float
    complex z);
long double complex
  
  csqrtl(long
    double complex z);
The
    csqrt(),
    csqrtf(),
    and
    csqrtl()
    functions compute the square root of z in the complex
    plane, with a branch cut along the negative real axis. In other words,
    csqrt(), csqrtf(), and
    csqrtl() always return the square root whose real
    part is non-negative.
These functions return the requested square root. The square root
    of 0 is +0 ± 0, where the imaginary parts of
    the input and respective result have the same sign. For infinities and NaNs,
    the following rules apply, with the earlier rules having precedence:
  
    | Input | 
    Result | 
     | 
  
  
    | k + infinity*I | 
    infinity + infinity*I | 
    (for all k) | 
  
  
    | -infinity + NaN*I | 
    NaN ± infinity*I | 
     | 
  
  
    | infinity + NaN*I | 
    infinity + NaN*I | 
     | 
  
  
    | k + NaN*I | 
    NaN + NaN*I | 
     | 
  
  
    | NaN + k*I | 
    NaN + NaN*I | 
     | 
  
  
    | -infinity + k*I | 
    +0 + infinity*I | 
     | 
  
  
    | infinity + k*I | 
    infinity + 0*I | 
     | 
  
For numbers with negative imaginary parts, the above special cases
    apply given the identity:
csqrt(conj(z)) =
  conj(csqrt(z))
Note that the sign of NaN is indeterminate. Also, if the real or imaginary part
  of the input is finite and an NaN is generated, an invalid exception will be
  thrown.
The csqrt(),
    csqrtf(), and csqrtl()
    functions conform to ISO/IEC 9899:1999
    (“ISO C99”).
For csqrt() and
    csqrtl(), inexact results are not always correctly
    rounded.