studio - superponer graficas en r

¿Cuál es la diferencia entre el modo y la clase en R?

Question

Estoy aprendiendo R (comencé esta semana), y he estado luchando con los conceptos de typeof, mode, storage.mode y class. He estado buscando arriba y abajo (documentación oficial de R, StackOverflow, Google, etc.), y no he podido encontrar una explicación clara de la diferencia entre estos. (Algunas respuestas de StackOverflow and CrossValidated realmente no me han ayudado a CrossValidated ). Finalmente (espero), creo que lo entiendo, por lo que mi pregunta es para verificar si mi comprensión es correcta.

mode vs storage.mode: mode y storage.mode son básicamente lo mismo , excepto por una pequeña diferencia en cómo se maneja el tipo de datos "único".

mode vs typeof: Muy similar, excepto por algunas diferencias , especialmente entre ambos (typeof "integer" y "double") = (mode "numeric"); y ambos (typeof "special" y "builtin" = (mode "function").

clase: la clase se basa en la jerarquía de clases orientada a objetos de R. Me está costando mucho encontrar esto gráficamente, pero lo mejor que he podido encontrar es este diagrama:

(Si alguien puede indicarme una jerarquía de clase R más precisa, la reemplazaré).

Aunque los nombres de las clases no se corresponden exactamente con los resultados de la función R class (), creo que la jerarquía es básicamente precisa. Entiendo que la "clase" de un objeto, es decir, el resultado de la función class (), es la clase raíz en la jerarquía. Entonces, por ejemplo, "Vector" no es una clase raíz y por lo tanto nunca aparece como el resultado de la función class (). La clase raíz podría ser "StrVector" ("carácter") o "BoolVector" ("lógico"). En contraste, "Matrix" es en sí misma una clase raíz; Por lo tanto, su clase es "matriz".

Aparentemente, R admite herencia múltiple, por lo que algunos objetos pueden tener más de una clase.

typeof / mode / storage.mode vs class: esta es la parte más difícil para mi entender. Mi comprensión ahora es esta: typeof / mode / storage.mode (al que me referiré en adelante simplemente como "mode") es básicamente el tipo de datos más complejo que un objeto R puede contener como uno de sus valores . Así, por ejemplo, dado que las matrices, matrices y vectores pueden contener solo un tipo de datos vectoriales, su modo (es decir, el tipo de datos más complejo que pueden contener) es generalmente numérico, de caracteres o lógico, aunque su clase (su posición en la clase) jerarquía) es algo completamente diferente.

Donde esto se vuelve más interesante (es decir, confuso) es con objetos como listas. Un modo de "lista" significa que cada valor en el objeto puede ser una lista (es decir, un objeto que puede contener diversos tipos de datos). Por lo tanto, independientemente de si la clase en sí misma es "lista", hay varios objetos (por ejemplo, marcos de datos) que pueden contener diversos valores, y cuyo modo es por lo tanto "lista", incluso si su clase es otra cosa.

Entonces, en resumen, mi entendimiento es:

• typeof / mode / storage.mode (casi lo mismo) es básicamente el tipo de datos más complejo que un objeto R puede contener como uno de sus valores; mientras

• clase es la clasificación orientada a objetos de un objeto de acuerdo con la jerarquía de la clase R.

¿Es mi entendimiento exacto? Si no, ¿podría alguien dar una explicación más precisa?

Answer 1

''modo'' es una clasificación mutuamente exclusiva de los objetos según su estructura básica. Los modos ''atómicos'' son numéricos, complejos, característicos y lógicos. Los objetos recursivos tienen modos como ''lista'' o ''función'' o algunos otros. Un objeto tiene uno y solo un modo.

''clase'' es una propiedad asignada a un objeto que determina cómo funcionan las funciones genéricas con él. No es una clasificación mutuamente excluyente. Si un objeto no tiene una clase específica asignada, como un simple vector numérico, su clase es generalmente la misma que su modo, por convención.

Cambiar el modo de un objeto a menudo se llama ''coerción''. El modo de un objeto puede cambiar sin cambiar necesariamente la clase. p.ej

> x <- 1:16
> mode(x)
[1] "numeric"
> dim(x) <- c(4,4)
> mode(x)
[1] "numeric"
> class(x)
[1] "matrix"
> is.numeric(x)
[1] TRUE
> mode(x) <- "character"
> mode(x)
[1] "character"
> class(x)
[1] "matrix"

Sin embargo:

> x <- factor(x)
> class(x)
[1] "factor"
> mode(x)
[1] "numeric"

En esta etapa, aunque x tiene el modo numérico nuevamente, su nueva clase, factor , impide que se use en operaciones aritméticas.

En la práctica, el modo no se usa mucho, excepto para definir una clase implícitamente cuando no se ha asignado una clase explícita.

Answer 2

Espero que los siguientes ejemplos sean útiles. En particular, eche un vistazo a los dos últimos ejemplos.

x <- 1
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- letters
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- TRUE
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- cars
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- cars[1]
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- cars[[1]]
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- matrix(cars)
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- new.env()
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- expression(1 + 1)
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- quote(y <- 1 + 1)
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- ls
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

Los resultados son

[1] "numeric" "numeric" "double"  "double" 
[1] "character" "character" "character" "character"
[1] "logical" "logical" "logical" "logical"
[1] "data.frame" "list"       "list"       "list"      
[1] "data.frame" "list"       "list"       "list"      
[1] "numeric" "numeric" "double"  "double" 
[1] "matrix" "list"   "list"   "list"  
[1] "environment" "environment" "environment" "environment"
[1] "expression" "expression" "expression" "expression"
[1] "<-"       "call"     "language" "language"
[1] "function" "function" "function" "closure" 

El último ejemplo le muestra un caso donde typeof ()! = Storage.mode ().