## NAME

clog(), clogf(), clogl(), clogw(), clogq() — complex natural (base-e) logarithm functions

## SYNOPSIS

`#include <complex.h>`

`double complex clog(double complex z);`

`float complex clogf(float complex z);`

`long double complex clogl(long double complex z);`

`extended complex clogw(extended complex z);`

`quad complex clogq(quad complex z);`

## DESCRIPTION

These functions are available only for Integrity servers.

`clog()`
returns the
complex natural logarithm of
`z`
in the range of a strip mathematically unbounded
along the real axis and in the interval [-iPi,+iPi] along
the imaginary axis.
There is a branch cut along the negative real axis.

`clogf()`
is a
`float`
`complex`
version of
`clog()`;
it takes a
`float`
`complex`
argument and returns a
`float`
`complex`
result.

`clogl()`
is a
`long`
`double`
`complex`
version of
`clog()`;
it takes a
`long`
`double`
`complex`
argument and returns a
`long`
`double`
`complex`
result.

`clogw()`
is an
`extended`
`complex`
version of
`clog()`;
it takes an
`extended`
`complex`
argument and returns an
`extended`
`complex`
result.

`clogq()`
is equivalent to
`clogl()`
on HP-UX systems.

## USAGE

To use these functions,
compile with the default
`-Ae`
option.
To use
`clogw()` or
`clogq()`,
compile with the
`-fpwidetypes`
option.
Make sure your program includes
`<complex.h>`.
Link in the math library by specifying
`-lm`
on the compiler or linker command line.

## RETURN VALUE

`clog(conj(``z``))`
=
`conj(clog(``z``))`.

`clog(`-0+i0`)`
returns -Inf+iPi and raises the divide-by-zero
floating-point exception.

`clog(`+0+i0`)`
returns -Inf+i0 and raises the divide-by-zero
floating-point exception.

`clog(``x`+iInf`)`
returns +Inf+iPi/2, for finite
`x`.

`clog(``x`+iNaN`)`
returns NaN+iNaN and optionally raises the invalid
floating-point exception, for finite
`x`.

`clog(`-Inf+i`y``)`
returns +Inf+iPi, for finite positive-signed
`y`.

`clog(`+Inf+i`y``)`
returns +Inf+i0, for finite positive-signed
`y`.

`clog(`-Inf+iInf`)`
returns +Inf+i3Pi/4.

`clog(`+Inf+iInf`)`
returns +Inf+ipi/4.

`clog(`±Inf+iNaN`)`
returns +Inf+iNaN.

`clog(`NaN+i`y``)`
returns NaN+iNaN and optionally raises the invalid
floating-point exception, for finite
`y`.

`clog(`NaN+iInf`)`
returns +Inf+iNaN.

`clog(`NaN+iNaN`)`
returns NaN+iNaN.

## ERRORS

No errors are defined.

## STANDARDS CONFORMANCE

`clog()`,
`clogf()`,
`clogl()`
: ISO/IEC C99 (including Annex G, ``IEC 60559-compatible complex arithmetic'')