Universidad del Bio Bio

Facultad de Ciencias
Magister Mencin Estadstica
Informtica I
Programacin del comando cuantile (Quantile)
Alumno: Ivn Aliaga Casceres.
Prof.: Sergio Contreras
Abril de 2015
Resumen
Se presenta la programacin del comando quantile en el programa R, para tal fin se realiza un anlisis del
paper Samples Quantiles in Statistical Packages del autor Rob J. Hyndman y Yanan Fan.

1.

Introduccin
Primeramente la distribucin de los cuantiles se definen como:
Q( p) = F 1 ( p) = in f { x : F ( x ) p} , 0 < p < 1

Donde F ( x ) es la funcin de distribucin. Los cuantiles proporcionan un estimador no paramtrico para las
partes n
de una poblacin
o basada en una muestra de observaciones independientes { X1 , . . . , Xn }de la distribucin

F. Sea X(1) , . . . , X(n) los estadsticos de orden de { X1 , . . . , Xn } y sea Q i ( p) la definicin de cuantil i esima
o el

mtodo de estimacin i esimo

estimado i=1,. . .,9.
Una dificultad en la comparacin de la definicin de cuantil es que hay un nmero notable de maneras en
el clculo equivalentes en la definicin entre ellos. Sin embargo, los cuantiles que se utilizan en los paquetes
estadsticos se basan en el clculo de uno o dos estadsticos de orden, y se pueden escribir como.
Q i ( p) = (1 ) X( j) + X( j+1)
Donde

jm
jm+1
p<
n
n

El valor de esta en funcin de j=b pn + mc1 y g=pn + m j.

Se observa los siguientes 9 metodos algortmicos que se basan a partir de 1.

2.

Algoritmos

2.1.

Definicin 1

Esta primera definicin es la inversa de la distribucin empirica que se obtiene haciendo m=0.
(
1 g>0
=
0 g=0
1 buc

denota el valor entero ms grande no mayor al valor u; d x e denota el valor entero mas pequeo no menor al valor x.

(1)

Para esta definicin2

Freq Xk Q 1 ( p) =d pne

y


Freq Xk = Q 1 (1 p) =b pn + 1c

2.2.

Definicin 2

La definicin 2 es similar a la definicin 1 excepto que se usa un promedio cuando g=0 dado que m = 0.
(
1
g=0
= 2
1 g>0
y


Freq Xk Q 2 ( p) = Freq( Xk Q 2 (1 p)) = d pne

2.3.

Definicin 3

En esta definicin Q 3 ( p) se define como estadistico de orden X(k) donde k es el valor entero ms cercanoa np.
Asi tenemos que m= 21 y cuando g > 0, asi.
(
0 g=0 y j es par
=
1 E.O.C.
bajo esta definicin:
(
Freq( Xk Q 3 ( p))=

b pnc
g = 0, y b pnc par
1
b pn + 2 c E.O.C.

y
(
Freq( Xk Q 3 (1 p))=

2.4.

b pn + 21 c g = 0 y b(1 p)nc par

b pn + 1c E.O.C.

Definicin 4

Parzen (1979) sugiere el clculo por interpolacin en el paso de la definicin 1, esto equivale a realizar pk = nk .

2.5.

Deinicin 5

Una definicin muy antigua definido por Hazen, esta basado en pk =(k 1/2)/n., este es un valor que tiene se
define en la primera definicon .
Ahora se L una medida de estimacin de localidad3 hay dos clases definiciones de cuantiles, la primera aplica
pk =LF ( X(k) ) y la seguna a pk = F ( L( X(k) )), si F tiene distribucin uniforme, dos aplicaciones son equivalentes, si
L denota la mediana y F es estrictamente monotona las dos aplicaciones son equivalentes porque la mediana es
invariante ante transformaciones monotonas.
Siguiendo la primera aplicacin, cuando F ( Xk ) tiene la forma de distribucin de F ( X(k) ) de una distribucion
estadstico k-ordenado de una distribucion uniforme, llamado distribucin beta (k, n k + 1), dado que esta
distribucin es libre el resultado no depende de la distribucin F , de esta forma se tiene que:
Q( pk )=Q( F ( LX(k) )) = LX(k) = Q i ( pk )
2 Freq ( X
3 Media,

x )Denota el nmero de observaciones menores o iguales a x.

mediana o la moda.

2.6.

Definicion 6

k
Weibull (1939) y Gumbel (1939) proponen pk = n+
1 . En este caso pk =E F ( X(k ) ) y los vertices se dividen en una
muestra del espacio en n + 1 regiones cada uno con probabilidad 1/(n + 1), en particular.

Pr ( X < X(1) ) = Pr ( X > X(n) ) = 1/(n + 1)

2.7.

Definicin 7

Gumbel (1939) tambien considera la posicin modal pk =moda( F ( X(k) )) = (k 1)/(n 1) una propiedad interesante es que los vertices de Q 7 ( p) divide el rango en n 1 intervalos y exctamente 100p % de los intervalos
que estan a la izquierda de Q 7 ( p) y 100(1 p) % que estan a la derecha de Q 7 ( p).

2.8.

Definicion 8

La posicin de la mediana es dificil de obtener por lo que se obtiene aproximando con la formula:
pk =(k 1/3)/(n + 1/3)

2.9.

Definicin 9

Blom (1958) muestra que pk = (k 3/8)/(n + 1/4) para la arproximacin a F ( EXk ) para la distribucin normal. Sin embargo Q 9 ( pk ) es insesgado y estima a Q( pk ) cuando F tiene una distribucin normal puesto que esta
definicin es usada para obtener el QQ-plot de una muestra general de la definicin de cuantil.

3.

Implementacin en R
Los algoritmos anteriormente citados se implementan en R y su codigo fuente es la siguiente:

> x<-seq(14,0,by=-2)
> quantile_ivan <- function(x,
+
probabilidad = seq(0, 1, 0.25),
+
tipo){
+ # x es variable numerica.
+ # probabilidad es una secuencia de probabilidades por defecto cuartiles.
+ # tipo: tipo de algoritmo va del 1 al 9.
+ n<- length(x)
+ if(tipo==1){
#caso 1 m=0
+
nppm <- n * probabilidad
+
# valor entero mas grande no mayor al valor nppm
+
j<- floor(nppm)
+
# ordenar al indice partial
+
gamma <- (nppm > j)
+
x <- sort(x, partial = unique(c(1, j[j>0 & j<=n], (j+1)[j>0 & j<n], n)))
+
x <- c(x[1], x[1], x, x[n], x[n]) # adicionamos el maximo y el minimo.
+
q <- x[j+2]# recorremos el indice j por el minimo
+
q[gamma == 1] <- x[j+3][gamma == 1]
+
# gamma esta entre 0 y 1 ?
+
preggamma <- (0 < gamma) & (gamma < 1)
+
# incorporar restricion
+
if(any(preggamma)) q[preggama] <- ((1-gamma)*x[j+2] + gamma*x[j+3])[preggamma]
+
names(q) <- paste0(round(100*probabilidad,0),"%") # colocando nombres
+
return(q)
+ } else {
+
if(tipo==2) {
+
#caso 2 m=0
3

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

nppm <- n * probabilidad

# valor entero mas grande no mayor al valor nppm
j <- floor(nppm)
gamma <-((nppm > j) + 1)/2
# ordenar al indice partial
x <- sort(x, partial = unique(c(1, j[j>0 & j<=n], (j+1)[j>0 & j<n], n)))
# adicionamos el maximo y el minimo.
x <- c(x[1], x[1], x, x[n], x[n])
q <- x[j+2]# recorremos el indice j por el minimo
q[gamma == 1] <- x[j+3][gamma == 1]
# gamma esta entre 0 y 1 ?
preggamma <- (0 < gamma) & (gamma < 1)
# incorporar restricion
if(any(preggamma)) q[preggamma] <- ((1-gamma)*x[j+2] + gamma*x[j+3])[preggamma]
names(q) <- paste0(round(100*probabilidad,0),"%") # colocando nombres
return(q)
} else {
if(tipo==3){
nppm <- n * probabilidad - .5
# m=-0.5
j <- floor(nppm)
gamma<- (nppm != j) | ((j %% 2) == 1) # j impar
x <- sort(x, partial = unique(c(1, j[j>0 & j<=n], (j+1)[j>0 & j<n], n)))
x <- c(x[1], x[1], x, x[n], x[n]) # adicionamos el maximo y el minimo.
q <- x[j+2]# recorremos el indice j por el minimo
q[gamma == 1] <- x[j+3][gamma == 1]
# gamma esta entre 0 y 1 ?
preggamma <- (0 < gamma) & (gamma < 1)
if(any(preggamma)) q[preggamma] <- ((1-gamma)*x[j+2] + gamma*x[j+3])[preggamma]
names(q) <- paste0(round(100*probabilidad,0),"%") # colocando nombres
return(q)
}else{
if(tipo==4){
a0 <- 0
a1 <- 1
nppm <- a0 + probabilidad * (n + 1 - a0 - a1)
epequenha<-0.000000001 # constante epsilon pequenho
j <- floor(nppm + epequenha)
gamma <- nppm - j
# gamma no es 0 1
if(any(indice <- abs(gamma) < epequenha)) gamma[indice] <- 0 # gamma es 0 1
x <- sort(x, partial = unique(c(1, j[j>0 & j<=n], (j+1)[j>0 & j<n], n))) #
x <- c(x[1], x[1], x, x[n], x[n]) # adicionamos el maximo y el minimo.
q <- x[j+2]# recorremos el indice j por el minimo
q[gamma == 1] <- x[j+3][gamma == 1]
preggamma <- (0 < gamma) & (gamma < 1) # gamma esta entre 0 y 1 ?
if(any(preggamma)) q[preggamma] <- ((1-gamma)*x[j+2] + gamma*x[j+3])[preggamma]
names(q) <- paste0(round(100*probabilidad,0),"%") # colocando nombres
return(q)
} else {
if(tipo==5){
a0 <- 0.5
a1 <- 0.5
nppm <- a0 + probabilidad * (n + 1 - a0 - a1)
epequenha<-0.000000001 # constante epsilon pequenho
j <- floor(nppm + epequenha)
gamma <- nppm - j
# gamma no es 0 1

+
+
+
+
+
+
+
+
+

if(any(indice <- abs(gamma) < epequenha)) gamma[indice] <- 0 # gamma es 0 1

x <- sort(x, partial = unique(c(1, j[j>0 & j<=n], (j+1)[j>0 & j<n], n))) #
x <- c(x[1], x[1], x, x[n], x[n]) # adicionamos el maximo y el minimo.
q <- x[j+2]# recorremos el indice j por el minimo
q[gamma == 1] <- x[j+3][gamma == 1]
preggamma <- (0 < gamma) & (gamma < 1) # gamma esta entre 0 y 1 ?
if(any(preggamma)) q[preggamma] <- ((1-gamma)*x[j+2] + gamma*x[j+3])[preggamma]
names(q) <- paste0(round(100*probabilidad,0),"%") # colocando nombres
return(q)

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

} else {
if (tipo==6){
a0 <- 0
a1 <- 0
nppm <- a0 + probabilidad * (n + 1 - a0 - a1)
epequenha<-0.000000001 # constante epsilon pequenho
j <- floor(nppm + epequenha)
gamma <- nppm - j
# gamma no es 0 1
if(any(indice <- abs(gamma) < epequenha)) gamma[indice] <- 0 # gamma es 0 1
x <- sort(x, partial = unique(c(1, j[j>0 & j<=n], (j+1)[j>0 & j<n], n))) #
x <- c(x[1], x[1], x, x[n], x[n]) # adicionamos el maximo y el minimo.
q <- x[j+2]# recorremos el indice j por el minimo
q[gamma == 1] <- x[j+3][gamma == 1]
preggamma <- (0 < gamma) & (gamma < 1) # gamma esta entre 0 y 1 ?
if(any(preggamma)) q[preggamma] <- ((1-gamma)*x[j+2] + gamma*x[j+3])[preggamma]
names(q) <- paste0(round(100*probabilidad,0),"%") # colocando nombres
return(q)

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

} else {
if (tipo==7){
nppm <- 1 + (n - 1) * probabilidad # definicion dada por gumbel
lim_inf <- floor(nppm)
lim_sup <- ceiling(nppm)
x <- sort(x, partial = unique(c(lim_inf, lim_sup)))
q <- x[lim_inf]
j <- which(nppm > lim_inf)
gamma <- (nppm - lim_inf)[j] #
q[j] <- (1 - gamma) * q[j] + gamma * x[lim_sup[j]]
names(q) <- paste0(round(100*probabilidad,0),"%") # colocando nombres
return(q)
} else {
if(tipo==8){
a0 <- 1/3
a1 <- 1/3
nppm <- a0 + probabilidad * (n + 1 - a0 - a1)
epequenha<-0.000000001 # constante epsilon pequenho
j <- floor(nppm + epequenha)
gamma <- nppm - j
# gamma no es 0 1
if(any(indice <- abs(gamma) < epequenha)) gamma[indice] <- 0 # gamma es 0 1
x <- sort(x, partial = unique(c(1, j[j>0 & j<=n], (j+1)[j>0 & j<n], n))) #
x <- c(x[1], x[1], x, x[n], x[n]) # adicionamos el maximo y el minimo.
q <- x[j+2]# recorremos el indice j por el minimo
q[gamma == 1] <- x[j+3][gamma == 1]
preggamma <- (0 < gamma) & (gamma < 1) # gamma esta entre 0 y 1 ?
if(any(preggamma)) q[preggamma] <- ((1-gamma)*x[j+2] + gamma*x[j+3])[preggamma]
names(q) <- paste0(round(100*probabilidad,0),"%") # colocando nombres

return(q)

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

} else{
if(tipo==9){
a0 <- 3/8
a1 <- 3/8
nppm <- a0 + probabilidad * (n + 1 - a0 - a1)
epequenha<-0.000000001 # constante epsilon pequenho
j <- floor(nppm + epequenha)
gamma <- nppm - j
# gamma no es 0 1
if(any(indice <- abs(gamma) < epequenha)) gamma[indice] <- 0 # gamma es 0 1
x <- sort(x, partial = unique(c(1, j[j>0 & j<=n], (j+1)[j>0 & j<n], n))) #
x <- c(x[1], x[1], x, x[n], x[n]) # adicionamos el maximo y el minimo.
q <- x[j+2]# recorremos el indice j por el minimo
q[gamma == 1] <- x[j+3][gamma == 1]
preggamma <- (0 < gamma) & (gamma < 1) # gamma esta entre 0 y 1 ?
if(any(preggamma)) q[preggamma] <- ((1-gamma)*x[j+2] + gamma*x[j+3])[preggamma]
names(q) <- paste0(round(100*probabilidad,0),"%") # colocando nombres
return(q)
} else {
print("No implementado")
}
}
}

}
}

+ }
+ }
Realizando pruebas

> # Datos simulados

> a<- round(runif(250,min=0,max=250),0)
> head(a)
# [1] 215
>
>
>
>
#
#

95 187 163 242 161

# cuartiles
probabilidad <-seq(0,1,0.25)
# definicin 1
quantile(a, type=1)
0%
1

25% 50% 75% 100%

59 121 185 249

> quantile_ivan(a,tipo=1,probabilidad=probabilidad)
#
#

0%
1

25% 50% 75% 100%

59 121 185 249

> # definicin 2
> quantile(a, type=2)
#
#

0%
1.0

25%
50%
75% 100%
59.0 121.5 185.0 249.0
6

> quantile_ivan(a,tipo=2,probabilidad=probabilidad)
#
#

0%
1.0

25%
50%
75% 100%
59.0 121.5 185.0 249.0

> # definicin 3
> probabilidad <- c(0.5,0.75,0.90)
> quantile(a, probs=probabilidad,type=3)
# 50% 75% 90%
# 121 185 224
> quantile_ivan(a,tipo=3,probabilidad=probabilidad)
# 50% 75% 90%
# 121 185 224
> # definicin 4
> probabilidad <- seq(0,1,0.25)
> quantile(a, probs=probabilidad,type=4)
#
#

0%
1

25% 50% 75% 100%

59 121 184 249

> quantile_ivan(a,tipo=4,probabilidad=probabilidad)
#
#

0%
1

25% 50% 75% 100%

59 121 184 249

> # definicin 5
> probabilidad <- seq(0,1,0.25)
> quantile(a, probs=probabilidad,type=5)
#
#

0%
1.0

25%
50%
75% 100%
59.0 121.5 185.0 249.0

> quantile_ivan(a,tipo=5,probabilidad=probabilidad)
#
#

0%
1.0

25%
50%
75% 100%
59.0 121.5 185.0 249.0

> # definicin 6
> probabilidad <- seq(0,1,0.25)
> quantile(a, probs=probabilidad,type=6)
#
#

0%
1.00

25%
50%
75%
100%
59.00 121.50 185.25 249.00

> quantile_ivan(a,tipo=6,probabilidad=probabilidad)
#
#

0%
1.00

25%
50%
75%
100%
59.00 121.50 185.25 249.00

> # definicin 7
> probabilidad <- seq(0,1,0.2)
> quantile(a, probs=probabilidad,type=7)
#
#

0%
1.0

20%
44.8

40%
60%
80% 100%
90.8 156.4 199.0 249.0

> quantile_ivan(a,tipo=7,probabilidad=probabilidad)
7

#
#

0%
1.0

20%
44.8

40%
60%
80% 100%
90.8 156.4 199.0 249.0

> # definicin 8
> probabilidad <- seq(0,1,0.25)
> quantile(a, probs=probabilidad,type=8)
#
#

0%
1.0000

25%
50%
75%
100%
59.0000 121.5000 185.0833 249.0000

> quantile_ivan(a,tipo=8,probabilidad=probabilidad)
#
#

0%
1.0000

25%
50%
75%
100%
59.0000 121.5000 185.0833 249.0000

> # definicin 9
> probabilidad <- seq(0,1,0.25)
> quantile(a, probs=probabilidad,type=9)
#
#

0%
1.0000

25%
50%
75%
100%
59.0000 121.5000 185.0625 249.0000

> quantile_ivan(a,tipo=9,probabilidad=probabilidad)
#
#

0%
1.0000

25%
50%
75%
100%
59.0000 121.5000 185.0625 249.0000