Tutorial R: Sistema S4: clases formales y validación

Definición formal de clases con setClass()

El sistema S4 en R representa un enfoque estructurado para la programación orientada a objetos, ofreciendo mayor formalidad que el sistema S3 que vimos anteriormente. A diferencia de S3, donde las clases son bastante flexibles, S4 proporciona un marco más riguroso para definir clases con estructura predeterminada.

La función setClass() es el punto de partida para crear clases en el sistema S4. Esta función nos permite definir formalmente una clase especificando su nombre, atributos (llamados "slots") y otras características.

Sintaxis básica de setClass()

La estructura básica para definir una clase S4 es:

setClass(
  Class,      # Nombre de la clase
  slots,      # Definición de atributos
  prototype   # Valores predeterminados (opcional)
)

Veamos un ejemplo sencillo para entender mejor cómo funciona:

# Definimos una clase Persona
setClass(
  "Persona",
  slots = c(
    nombre = "character",
    edad = "numeric"
  )
)

En este ejemplo, hemos creado una clase llamada "Persona" con dos atributos (slots): nombre (de tipo character) y edad (de tipo numeric).

Creación de objetos

Una vez definida la clase, podemos crear instancias (objetos) de esta clase utilizando la función new():

# Creamos un objeto de la clase Persona
ana <- new("Persona", nombre = "Ana García", edad = 28)

# Verificamos la clase del objeto
class(ana)  # Devuelve "Persona"

Acceso a los slots

Para acceder a los atributos de un objeto S4, utilizamos el operador @ o la función slot():

# Accediendo a los slots con @
ana@nombre  # "Ana García"
ana@edad    # 28

# Alternativamente, usando la función slot()
slot(ana, "nombre")  # "Ana García"

El operador @ es similar al operador $ que usamos con listas, pero específico para objetos S4.

Valores predeterminados con prototype

Podemos establecer valores predeterminados para los slots utilizando el argumento prototype:

setClass(
  "Estudiante",
  slots = c(
    nombre = "character",
    edad = "numeric",
    curso = "character",
    promedio = "numeric"
  ),
  prototype = list(
    curso = "No asignado",
    promedio = 0
  )
)

# Creamos un estudiante sin especificar todos los slots
estudiante1 <- new("Estudiante", nombre = "Carlos", edad = 20)

# Los valores no especificados toman los valores del prototype
estudiante1@curso     # "No asignado"
estudiante1@promedio  # 0

Clases con herencia

S4 permite definir relaciones de herencia entre clases mediante el parámetro contains:

# Definimos una clase EstudianteGraduado que hereda de Estudiante
setClass(
  "EstudianteGraduado",
  slots = c(
    especialidad = "character",
    asesor = "character"
  ),
  contains = "Estudiante"
)

# Creamos un objeto de la clase EstudianteGraduado
graduado <- new("EstudianteGraduado",
                nombre = "Laura",
                edad = 24,
                curso = "Maestría",
                especialidad = "Estadística",
                asesor = "Dr. Martínez")

# Podemos acceder tanto a los slots propios como a los heredados
graduado@nombre        # "Laura"
graduado@especialidad  # "Estadística"

Verificación de clases

Podemos verificar si un objeto pertenece a una clase específica utilizando la función is():

# Verificamos si graduado es un EstudianteGraduado
is(graduado, "EstudianteGraduado")  # TRUE

# También es un Estudiante debido a la herencia
is(graduado, "Estudiante")  # TRUE

Ejemplo práctico: Clase Rectángulo

Veamos un ejemplo más completo con una clase que representa un rectángulo:

# Definimos la clase Rectangulo
setClass(
  "Rectangulo",
  slots = c(
    ancho = "numeric",
    alto = "numeric"
  ),
  prototype = list(
    ancho = 1,
    alto = 1
  )
)

# Creamos algunos rectángulos
rect1 <- new("Rectangulo")  # Usa los valores predeterminados
rect2 <- new("Rectangulo", ancho = 5, alto = 3)

# Calculamos el área (por ahora sin métodos formales)
calcular_area <- function(rectangulo) {
  return(rectangulo@ancho * rectangulo@alto)
}

# Probamos la función
calcular_area(rect1)  # 1 (1×1)
calcular_area(rect2)  # 15 (5×3)

Ventajas de usar setClass()

El uso de setClass() para definir clases S4 ofrece varias ventajas:

• Estructura formal: Las clases tienen una estructura predefinida y clara.
• Tipado de atributos: Cada slot tiene un tipo específico, lo que ayuda a prevenir errores.
• Valores predeterminados: Podemos establecer valores iniciales para los atributos.
• Herencia explícita: Las relaciones de herencia se definen formalmente.

Estas características hacen que el código sea más robusto y mantenible, especialmente en proyectos grandes o cuando se trabaja en equipo.

Consideraciones importantes

Al trabajar con clases S4, es importante tener en cuenta:

• Las clases S4 requieren que cargues el paquete methods, aunque normalmente ya está cargado en una sesión de R estándar.
• Los nombres de las clases suelen comenzar con mayúscula por convención.
• A diferencia de S3, en S4 no puedes añadir slots a un objeto después de crearlo.

# Esto generará un error
ana@direccion <- "Calle Principal 123"  # Error: no se puede añadir slots

El sistema S4 proporciona un marco más estructurado para la programación orientada a objetos en R, lo que resulta especialmente útil cuando necesitamos garantizar la consistencia de nuestros objetos y sus atributos.

Slots y validación de atributos

Los slots son la columna vertebral de las clases S4, funcionando como contenedores formales para los atributos de un objeto. A diferencia del sistema S3, donde los atributos son flexibles, en S4 cada slot tiene un tipo específico que debe respetarse. Esta característica nos permite implementar un nivel adicional de seguridad mediante la validación de atributos.

Tipos de datos para slots

Cuando definimos una clase con setClass(), debemos especificar el tipo de cada slot. R ofrece varios tipos básicos que podemos utilizar:

• character: para cadenas de texto
• numeric: para números (enteros o decimales)
• logical: para valores booleanos (TRUE/FALSE)
• integer: específicamente para números enteros
• list: para listas que pueden contener elementos heterogéneos
• matrix: para matrices
• data.frame: para marcos de datos
• Otras clases S4 definidas previamente

Veamos un ejemplo con diferentes tipos de slots:

setClass(
  "Producto",
  slots = c(
    codigo = "character",
    precio = "numeric",
    disponible = "logical",
    etiquetas = "list"
  )
)

# Creamos un objeto con diferentes tipos de datos
producto1 <- new("Producto",
                 codigo = "P001",
                 precio = 29.99,
                 disponible = TRUE,
                 etiquetas = list("electrónica", "oferta"))

Validación básica de tipos

La primera capa de validación ocurre automáticamente cuando creamos un objeto. Si intentamos asignar un valor de tipo incorrecto a un slot, R generará un error:

# Esto generará un error porque precio debe ser numérico
try(
  producto_error <- new("Producto",
                        codigo = "P002",
                        precio = "treinta euros",  # Error: debe ser numeric
                        disponible = TRUE,
                        etiquetas = list("hogar"))
)

Validación personalizada con setValidity()

La función setValidity() nos permite definir reglas de validación personalizadas para nuestras clases. Estas reglas van más allá de la simple comprobación de tipos y pueden incluir cualquier lógica que necesitemos:

# Definimos una clase con validación personalizada
setClass(
  "Cuenta",
  slots = c(
    titular = "character",
    saldo = "numeric",
    limite_credito = "numeric"
  )
)

# Añadimos reglas de validación
setValidity("Cuenta", function(object) {
  # Verificamos que el titular no esté vacío
  if (nchar(object@titular) == 0) {
    return("El nombre del titular no puede estar vacío")
  }
  
  # Verificamos que el saldo no sea negativo
  if (object@saldo < 0) {
    return("El saldo no puede ser negativo")
  }
  
  # Verificamos que el límite de crédito sea positivo
  if (object@limite_credito <= 0) {
    return("El límite de crédito debe ser mayor que cero")
  }
  
  # Si todas las validaciones pasan, retornamos TRUE
  return(TRUE)
})

La función de validación debe retornar TRUE si el objeto es válido, o un mensaje de error (string) si no lo es.

Ahora, cuando intentemos crear un objeto que no cumpla con estas reglas, R generará un error:

# Objeto válido
cuenta_valida <- new("Cuenta", 
                     titular = "María López", 
                     saldo = 1000, 
                     limite_credito = 500)

# Esto generará un error por saldo negativo
try(
  cuenta_invalida <- new("Cuenta", 
                         titular = "Juan Pérez", 
                         saldo = -200,  # Viola la regla de saldo no negativo
                         limite_credito = 300)
)

Validación de rangos y valores permitidos

Un caso común de validación es asegurarse de que los valores estén dentro de ciertos rangos o pertenezcan a un conjunto de valores permitidos:

setClass(
  "Calificacion",
  slots = c(
    estudiante = "character",
    asignatura = "character",
    nota = "numeric",
    estado = "character"
  )
)

# Validación de rangos y valores permitidos
setValidity("Calificacion", function(object) {
  # Validamos que la nota esté entre 0 y 10
  if (object@nota < 0 || object@nota > 10) {
    return("La nota debe estar entre 0 y 10")
  }
  
  # Validamos que el estado sea uno de los valores permitidos
  estados_validos <- c("aprobado", "suspenso", "pendiente")
  if (!object@estado %in% estados_validos) {
    return(paste("El estado debe ser uno de:", 
                 paste(estados_validos, collapse=", ")))
  }
  
  return(TRUE)
})

# Creamos una calificación válida
calificacion1 <- new("Calificacion",
                     estudiante = "Elena Gómez",
                     asignatura = "Estadística",
                     nota = 8.5,
                     estado = "aprobado")

# Esto generará un error por estado inválido
try(
  calificacion2 <- new("Calificacion",
                       estudiante = "Carlos Ruiz",
                       asignatura = "Programación",
                       nota = 6.7,
                       estado = "excelente")  # No está en la lista de estados válidos
)

Validación de relaciones entre slots

También podemos validar relaciones entre diferentes slots:

setClass(
  "Rectangulo",
  slots = c(
    ancho = "numeric",
    alto = "numeric",
    area = "numeric"
  )
)

# Validamos que el área sea consistente con ancho y alto
setValidity("Rectangulo", function(object) {
  area_calculada <- object@ancho * object@alto
  
  # Comprobamos si el área almacenada coincide con la calculada
  if (abs(object@area - area_calculada) > 0.0001) {  # Permitimos pequeñas diferencias por redondeo
    return("El área debe ser igual a ancho * alto")
  }
  
  return(TRUE)
})

# Creamos un rectángulo válido
rect_valido <- new("Rectangulo", ancho = 5, alto = 3, area = 15)

# Esto generará un error por área inconsistente
try(
  rect_invalido <- new("Rectangulo", ancho = 4, alto = 2, area = 10)  # Debería ser 8
)

Validación con initialize()

Otra forma de implementar validación es mediante el método initialize(), que se ejecuta cuando se crea un nuevo objeto. Esto nos permite calcular automáticamente valores o aplicar transformaciones:

setClass(
  "Circulo",
  slots = c(
    radio = "numeric",
    area = "numeric",
    perimetro = "numeric"
  )
)

# Definimos un método initialize personalizado
setMethod("initialize", "Circulo", function(.Object, radio, ...) {
  # Llamamos al inicializador de la clase base
  .Object <- callNextMethod(.Object, radio = radio, ...)
  
  # Calculamos automáticamente el área y el perímetro
  if (!missing(radio)) {
    .Object@area <- pi * radio^2
    .Object@perimetro <- 2 * pi * radio
  }
  
  # Retornamos el objeto inicializado
  return(.Object)
})

# Creamos un círculo especificando solo el radio
circulo <- new("Circulo", radio = 5)

# Los otros valores se calculan automáticamente
circulo@area       # Aproximadamente 78.54
circulo@perimetro  # Aproximadamente 31.42

Validación en tiempo de ejecución con validObject()

La función validObject() nos permite verificar explícitamente si un objeto cumple con sus reglas de validación en cualquier momento:

# Creamos un objeto válido
cuenta <- new("Cuenta", 
              titular = "Ana Martínez", 
              saldo = 500, 
              limite_credito = 1000)

# Modificamos directamente un slot
cuenta@saldo <- -100  # Esto hace que el objeto sea inválido

# Verificamos manualmente la validez
try(
  validObject(cuenta)  # Esto generará un error
)

# Corregimos el problema
cuenta@saldo <- 0
validObject(cuenta)  # Ahora es válido

Ventajas de la validación de atributos

La validación de atributos en S4 ofrece varias ventajas importantes:

• Integridad de datos: Garantiza que los objetos siempre contengan datos válidos.
• Detección temprana de errores: Los problemas se identifican en el momento de la creación o modificación.
• Autovalidación: Los objetos pueden verificar su propia consistencia interna.
• Documentación implícita: Las reglas de validación sirven como documentación sobre las restricciones de los datos.

La combinación de slots tipados y validación personalizada hace que el sistema S4 sea especialmente adecuado para modelar dominios complejos donde la integridad de los datos es crucial, como aplicaciones científicas, financieras o de análisis estadístico.

Métodos S4 con setMethod()

Los métodos son una parte fundamental de la programación orientada a objetos, ya que definen el comportamiento de los objetos. En el sistema S4 de R, los métodos se implementan formalmente mediante la función setMethod(), que nos permite asociar funciones específicas a combinaciones de clases.

A diferencia del sistema S3, donde los métodos se definen de manera más flexible, S4 proporciona un marco estructurado para la definición de métodos, permitiendo un control más preciso sobre qué función se ejecuta para cada tipo de objeto.

Estructura básica de setMethod()

La sintaxis básica para definir un método S4 es:

setMethod(
  f,           # Nombre del método genérico
  signature,   # Clases de los argumentos
  definition   # Función que implementa el método
)

Veamos cada componente:

• f: Es el nombre de la función genérica para la que estamos definiendo un método.
• signature: Especifica las clases de los argumentos para las que se aplicará este método.
• definition: Es la implementación del método, una función que se ejecutará cuando se llame al método genérico con objetos que coincidan con la firma.

Funciones genéricas

Antes de definir métodos específicos, necesitamos una función genérica. Podemos usar una existente o crear una nueva con setGeneric():

# Definimos una función genérica para calcular el área
setGeneric("calcularArea", function(objeto) {
  standardGeneric("calcularArea")
})

La llamada a standardGeneric() es crucial, ya que indica a R que debe buscar y ejecutar el método apropiado según la clase del objeto.

Implementando métodos para diferentes clases

Ahora podemos implementar el método calcularArea para diferentes clases:

# Definimos una clase Rectangulo
setClass(
  "Rectangulo",
  slots = c(
    ancho = "numeric",
    alto = "numeric"
  )
)

# Implementamos calcularArea para Rectangulo
setMethod(
  "calcularArea",
  signature("Rectangulo"),
  function(objeto) {
    return(objeto@ancho * objeto@alto)
  }
)

# Definimos una clase Circulo
setClass(
  "Circulo",
  slots = c(
    radio = "numeric"
  )
)

# Implementamos calcularArea para Circulo
setMethod(
  "calcularArea",
  signature("Circulo"),
  function(objeto) {
    return(pi * objeto@radio^2)
  }
)

Ahora podemos crear objetos y llamar al método:

# Creamos objetos
rect <- new("Rectangulo", ancho = 5, alto = 3)
circ <- new("Circulo", radio = 2)

# Llamamos al método genérico
calcularArea(rect)  # Devuelve 15
calcularArea(circ)  # Devuelve aproximadamente 12.57

El sistema S4 selecciona automáticamente el método adecuado según la clase del objeto.

Métodos con múltiples argumentos

Los métodos S4 pueden tener múltiples argumentos, y la firma puede especificar las clases para cada uno de ellos:

# Definimos una función genérica con dos argumentos
setGeneric("combinar", function(objeto1, objeto2) {
  standardGeneric("combinar")
})

# Implementamos un método para combinar dos rectángulos
setMethod(
  "combinar",
  signature("Rectangulo", "Rectangulo"),
  function(objeto1, objeto2) {
    # Creamos un nuevo rectángulo con dimensiones combinadas
    nuevo_ancho <- objeto1@ancho + objeto2@ancho
    nuevo_alto <- max(objeto1@alto, objeto2@alto)
    return(new("Rectangulo", ancho = nuevo_ancho, alto = nuevo_alto))
  }
)

Podemos usar este método para combinar dos rectángulos:

rect1 <- new("Rectangulo", ancho = 3, alto = 2)
rect2 <- new("Rectangulo", ancho = 4, alto = 5)

# Combinamos los rectángulos
rect_combinado <- combinar(rect1, rect2)

# Verificamos las dimensiones
rect_combinado@ancho  # 7
rect_combinado@alto   # 5

Métodos para funciones estándar

Podemos definir métodos S4 para funciones estándar de R, como show() (equivalente a print()), plot(), o los operadores aritméticos:

# Definimos un método show para Rectangulo
setMethod(
  "show",
  "Rectangulo",
  function(object) {
    cat("Rectángulo de", object@ancho, "x", object@alto, "\n")
    cat("Área:", object@ancho * object@alto, "\n")
  }
)

# Ahora cuando imprimimos un rectángulo, se usa nuestro método
rect <- new("Rectangulo", ancho = 4, alto = 3)
rect  # Muestra: "Rectángulo de 4 x 3, Área: 12"

Métodos con argumentos opcionales

Podemos definir métodos que acepten argumentos opcionales utilizando ... en la definición:

# Definimos una función genérica con argumentos opcionales
setGeneric("dibujar", function(objeto, ...) {
  standardGeneric("dibujar")
})

# Implementamos el método para Circulo
setMethod(
  "dibujar",
  "Circulo",
  function(objeto, color = "blue", relleno = FALSE, ...) {
    cat("Dibujando círculo de radio", objeto@radio, "\n")
    cat("Color:", color, "\n")
    cat("Relleno:", if(relleno) "Sí" else "No", "\n")
    # Aquí iría el código real para dibujar
  }
)

# Usamos el método con diferentes opciones
circ <- new("Circulo", radio = 5)
dibujar(circ)  # Usa valores predeterminados
dibujar(circ, color = "red", relleno = TRUE)  # Personaliza opciones

Herencia de métodos

Los métodos S4 respetan la jerarquía de herencia de clases. Si definimos un método para una clase base, las clases derivadas pueden utilizarlo:

# Definimos una clase base Figura
setClass(
  "Figura",
  slots = c(
    color = "character"
  )
)

# Hacemos que Rectangulo herede de Figura
setClass(
  "Rectangulo",
  slots = c(
    ancho = "numeric",
    alto = "numeric"
  ),
  contains = "Figura"
)

# Definimos un método para la clase base
setMethod(
  "show",
  "Figura",
  function(object) {
    cat("Figura de color", object@color, "\n")
  }
)

# Creamos un rectángulo
rect <- new("Rectangulo", ancho = 5, alto = 3, color = "verde")

# El método show de Figura se aplica a Rectangulo
rect  # Muestra: "Figura de color verde"

Podemos sobrescribir el método para la clase derivada si necesitamos un comportamiento específico:

# Sobrescribimos el método show para Rectangulo
setMethod(
  "show",
  "Rectangulo",
  function(object) {
    # Llamamos primero al método de la clase base
    callNextMethod()
    # Añadimos información específica del rectángulo
    cat("Dimensiones:", object@ancho, "x", object@alto, "\n")
  }
)

# Ahora el rectángulo muestra información más específica
rect  # Muestra: "Figura de color verde" seguido de "Dimensiones: 5 x 3"

Métodos para operadores

Podemos definir métodos para operadores como +, -, *, etc., lo que nos permite implementar operaciones personalizadas entre objetos:

# Definimos un método para el operador + entre dos rectángulos
setMethod(
  "+",
  signature("Rectangulo", "Rectangulo"),
  function(e1, e2) {
    # Sumamos las áreas y creamos un nuevo rectángulo cuadrado
    area_total <- (e1@ancho * e1@alto) + (e2@ancho * e2@alto)
    lado <- sqrt(area_total)  # Lado de un cuadrado con la misma área
    return(new("Rectangulo", ancho = lado, alto = lado))
  }
)

# Probamos la suma de rectángulos
rect1 <- new("Rectangulo", ancho = 3, alto = 4)  # Área = 12
rect2 <- new("Rectangulo", ancho = 2, alto = 5)  # Área = 10

rect_suma <- rect1 + rect2  # Área = 22
rect_suma@ancho  # Aproximadamente 4.69
rect_suma@alto   # Aproximadamente 4.69

Verificación de métodos disponibles

Podemos usar la función showMethods() para inspeccionar qué métodos están disponibles para una función genérica:

# Mostramos todos los métodos definidos para calcularArea
showMethods("calcularArea")

# Mostramos métodos para una clase específica
showMethods(class = "Rectangulo")

Ejemplo práctico: Sistema de gestión de formas

Veamos un ejemplo más completo que integra clases, validación y métodos:

# Definimos una clase base Forma
setClass(
  "Forma",
  slots = c(
    nombre = "character",
    color = "character"
  ),
  prototype = list(
    color = "negro"
  )
)

# Validación para la clase base
setValidity("Forma", function(object) {
  if (nchar(object@nombre) == 0) {
    return("El nombre no puede estar vacío")
  }
  return(TRUE)
})

# Definimos subclases
setClass(
  "Rectangulo",
  slots = c(
    ancho = "numeric",
    alto = "numeric"
  ),
  contains = "Forma",
  prototype = list(
    nombre = "rectángulo"
  )
)

setClass(
  "Circulo",
  slots = c(
    radio = "numeric"
  ),
  contains = "Forma",
  prototype = list(
    nombre = "círculo"
  )
)

# Definimos funciones genéricas
setGeneric("area", function(forma) standardGeneric("area"))
setGeneric("perimetro", function(forma) standardGeneric("perimetro"))
setGeneric("escalar", function(forma, factor) standardGeneric("escalar"))

# Implementamos métodos para Rectangulo
setMethod("area", "Rectangulo", function(forma) {
  return(forma@ancho * forma@alto)
})

setMethod("perimetro", "Rectangulo", function(forma) {
  return(2 * (forma@ancho + forma@alto))
})

setMethod("escalar", "Rectangulo", function(forma, factor) {
  forma@ancho <- forma@ancho * factor
  forma@alto <- forma@alto * factor
  return(forma)
})

# Implementamos métodos para Circulo
setMethod("area", "Circulo", function(forma) {
  return(pi * forma@radio^2)
})

setMethod("perimetro", "Circulo", function(forma) {
  return(2 * pi * forma@radio)
})

setMethod("escalar", "Circulo", function(forma, factor) {
  forma@radio <- forma@radio * factor
  return(forma)
})

# Método show personalizado para todas las formas
setMethod("show", "Forma", function(object) {
  cat(object@nombre, "de color", object@color, "\n")
})

# Probamos el sistema
rect <- new("Rectangulo", nombre = "Rectángulo A", color = "azul", ancho = 5, alto = 3)
circ <- new("Circulo", nombre = "Círculo B", color = "rojo", radio = 4)

# Mostramos las formas
rect  # "Rectángulo A de color azul"
circ  # "Círculo B de color rojo"

# Calculamos áreas y perímetros
area(rect)       # 15
perimetro(rect)  # 16
area(circ)       # Aproximadamente 50.27
perimetro(circ)  # Aproximadamente 25.13

# Escalamos las formas
rect_grande <- escalar(rect, 2)
area(rect_grande)  # 60 (4 veces el área original)

Este sistema de gestión de formas demuestra cómo los métodos S4 nos permiten implementar comportamientos específicos para diferentes clases, manteniendo una interfaz común a través de funciones genéricas.

La combinación de clases formales, validación de atributos y métodos específicos hace que el sistema S4 sea una herramienta poderosa para modelar dominios complejos en R, especialmente cuando necesitamos garantizar la integridad de los datos y comportamientos bien definidos.