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)
"plot"(x, ..., ylab="Fn(x)", verticals = FALSE, col.01line = "gray70", pch = 19)
"print"(x, digits= getOption("digits")  2, ...)
"summary"(object, ...)
"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 theplot
method.  ylab
 label for the yaxis.
 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) $Fn$ 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
$= ($$x1,x2$, ... $xn)$,
$Fn$ 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 recreated 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)
## 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?
print(ls.Fn12 < 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)