# ecdf

##### Empirical Cumulative Distribution Function

Compute an empirical cumulative distribution function, with several methods for plotting, printing and computing with such an “ecdf” object.

##### Usage

`ecdf(x)`# S3 method for ecdf
plot(x, …, ylab="Fn(x)", verticals = FALSE,
col.01line = "gray70", pch = 19)

# S3 method for ecdf
print(x, digits= getOption("digits") - 2, …)

# S3 method for ecdf
summary(object, …)
# S3 method for ecdf
quantile(x, …)

##### Arguments

- x, object
numeric vector of the observations for

`ecdf`

; for the methods, an object inheriting from class`"ecdf"`

.- …
arguments to be passed to subsequent methods, e.g.,

`plot.stepfun`

for the`plot`

method.- ylab
label for the y-axis.

- verticals
see

`plot.stepfun`

.- col.01line
numeric or character specifying the color of the horizontal lines at y = 0 and 1, see

`colors`

.- pch
plotting character.

- digits
number of significant digits to use, see

`print`

.

##### Details

The e.c.d.f. (empirical cumulative distribution function) \(F_n\) is a step function with jumps \(i/n\) at observation values, where \(i\) is the number of tied observations at that value. Missing values are ignored.

For observations
`x`

\(= (\)\(x_1,x_2\), … \(x_n)\),
\(F_n\) is the fraction of observations less or equal to \(t\),
i.e.,
$$F_n(t) = \#\{x_i\le t\}\ / n
= \frac1 n\sum_{i=1}^n \mathbf{1}_{[x_i \le t]}.$$

The function `plot.ecdf`

which implements the `plot`

method for `ecdf`

objects, is implemented via a call to
`plot.stepfun`

; see its documentation.

##### Value

For `ecdf`

, a function of class `"ecdf"`

, inheriting from the
`"stepfun"`

class, and hence inheriting a
`knots()`

method.

For the `summary`

method, a summary of the knots of `object`

with a `"header"`

attribute.

The `quantile(obj, ...)`

method computes the same quantiles as
`quantile(x, ...)`

would where `x`

is the original sample.

##### Note

The objects of class `"ecdf"`

are not intended to be used for
permanent storage and may change structure between versions of R (and
did at R 3.0.0). They can usually be re-created by

eval(attr(old_obj, "call"), environment(old_obj))

since the data used is stored as part of the object's environment.

##### See Also

`stepfun`

, the more general class of step functions,
`approxfun`

and `splinefun`

.

##### Examples

`library(stats)`

```
# NOT RUN {
##-- Simple didactical ecdf example :
x <- rnorm(12)
Fn <- ecdf(x)
Fn # a *function*
Fn(x) # returns the percentiles for x
tt <- seq(-2, 2, by = 0.1)
12 * Fn(tt) # Fn is a 'simple' function {with values k/12}
summary(Fn)
##--> see below for graphics
knots(Fn) # the unique data values {12 of them if there were no ties}
y <- round(rnorm(12), 1); y[3] <- y[1]
Fn12 <- ecdf(y)
Fn12
knots(Fn12) # unique values (always less than 12!)
summary(Fn12)
summary.stepfun(Fn12)
## Advanced: What's inside the function closure?
ls(environment(Fn12))
##[1] "f" "method" "n" "x" "y" "yleft" "yright"
utils::ls.str(environment(Fn12))
stopifnot(all.equal(quantile(Fn12), quantile(y)))
###----------------- Plotting --------------------------
require(graphics)
op <- par(mfrow = c(3, 1), mgp = c(1.5, 0.8, 0), mar = .1+c(3,3,2,1))
F10 <- ecdf(rnorm(10))
summary(F10)
plot(F10)
plot(F10, verticals = TRUE, do.points = FALSE)
plot(Fn12 , lwd = 2) ; mtext("lwd = 2", adj = 1)
xx <- unique(sort(c(seq(-3, 2, length = 201), knots(Fn12))))
lines(xx, Fn12(xx), col = "blue")
abline(v = knots(Fn12), lty = 2, col = "gray70")
plot(xx, Fn12(xx), type = "o", cex = .1) #- plot.default {ugly}
plot(Fn12, col.hor = "red", add = TRUE) #- plot method
abline(v = knots(Fn12), lty = 2, col = "gray70")
## luxury plot
plot(Fn12, verticals = TRUE, col.points = "blue",
col.hor = "red", col.vert = "bisque")
##-- this works too (automatic call to ecdf(.)):
plot.ecdf(rnorm(24))
title("via simple plot.ecdf(x)", adj = 1)
par(op)
# }
```

*Documentation reproduced from package stats, version 3.5.2, License: Part of R 3.5.2*