# complex

##### Complex Vectors

Basic functions which support complex arithmetic in R.

- Keywords
- complex

##### Usage

```
complex(length.out = 0, real = numeric(), imaginary = numeric(), modulus = 1, argument = 0)
as.complex(x, ...)
is.complex(x)
Re(z)
Im(z)
Mod(z)
Arg(z)
Conj(z)
```

##### Arguments

- length.out
- numeric. Desired length of the output vector, inputs being recycled as needed.
- real
- numeric vector.
- imaginary
- numeric vector.
- modulus
- numeric vector.
- argument
- numeric vector.
- x
- an object, probably of mode
`complex`

. - z
- an object of mode
`complex`

, or one of a class for which a methods has been defined. - ...
- further arguments passed to or from other methods.

##### Details

Complex vectors can be created with `complex`

. The vector can be
specified either by giving its length, its real and imaginary parts, or
modulus and argument. (Giving just the length generates a vector of
complex zeroes.)

`as.complex`

attempts to coerce its argument to be of complex
type: like `as.vector`

it strips attributes including
names. All forms of `NA`

and `NaN`

are coerced to a complex
`NA`

, for which both the real and imaginary parts are `NA`

.

Note that `is.complex`

and `is.numeric`

are never both
`TRUE`

.

The functions `Re`

, `Im`

, `Mod`

, `Arg`

and
`Conj`

have their usual interpretation as returning the real
part, imaginary part, modulus, argument and complex conjugate for
complex values. The modulus and argument are also called the *polar
coordinates*. If $z = x + i y$ with real $x$ and $y$, for
$r = Mod(z) = \sqrt(x^2 + y^2)$,
and $\phi = Arg(z)$, $x = r*cos(\phi)$ and
$y = r*sin(\phi)$. They are all
internal generic primitive functions: methods can be
defined for them
individually or *via* the `Complex`

group generic.

In addition, the elementary trigonometric, logarithmic, exponential, square root and hyperbolic functions are implemented for complex values.

Internally, complex numbers are stored as a pair of double
precision numbers, either or both of which can be `NaN`

or
plus or minus infinity.

##### S4 methods

`as.complex`

is primitive and can have S4 methods set. `Re`

, `Im`

, `Mod`

, `Arg`

and `Conj`

constitute the S4 group generic
`Complex`

and so S4 methods can be
set for them individually or via the group generic.

##### References

Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988)
*The New S Language*.
Wadsworth & Brooks/Cole.

##### Examples

`library(base)`

```
require(graphics)
0i ^ (-3:3)
matrix(1i^ (-6:5), nrow = 4) #- all columns are the same
0 ^ 1i # a complex NaN
## create a complex normal vector
z <- complex(real = stats::rnorm(100), imaginary = stats::rnorm(100))
## or also (less efficiently):
z2 <- 1:2 + 1i*(8:9)
## The Arg(.) is an angle:
zz <- (rep(1:4, len = 9) + 1i*(9:1))/10
zz.shift <- complex(modulus = Mod(zz), argument = Arg(zz) + pi)
plot(zz, xlim = c(-1,1), ylim = c(-1,1), col = "red", asp = 1,
main = expression(paste("Rotation by "," ", pi == 180^o)))
abline(h = 0, v = 0, col = "blue", lty = 3)
points(zz.shift, col = "orange")
```

*Documentation reproduced from package base, version 3.1.3, License: Part of R 3.1.3*