Luigi's questions

No meu entendimento, algumas classes de objetos personalizados têm uma plotfunção personalizada, que permite usar plot(object_name)e obter o gráfico que você (provavelmente) está interessado.

Por exemplo, posso obter da página de ajuda pmcalibration::pmcalibrationum código como o abaixo

library(pmcalibration)
library(survival)
  
data('transplant', package="survival")
transplant <- na.omit(transplant)
transplant = subset(transplant, futime > 0)
transplant$ltx <- as.numeric(transplant$event == "ltx")
  
cph <- coxph(Surv(futime, ltx) ~ age + sex + abo + year, data = transplant)
  
time <- 100
newd <- transplant; newd$futime <- time; newd$ltx <- 1
p <- 1 - exp(-predict(cph, type = "expected", newdata=newd))
y <- with(transplant, Surv(futime, ltx))
  
cal <- pmcalibration(y = y, p = p, smooth = "rcs", nk=5, ci = "pw", time = time)

class(cal)
  [1] "pmcalibration"

plot(cal)

Conforme mostrado, caltem a classe "pmcalibration", e é suficiente fornecê-la como argumento para a plotfunção para obter o gráfico de calibração que você certamente está interessado em obter após usar a pmcalibrationfunção

Minha pergunta é: como posso recuperar o que a plotfunção fez aqui? Como posso obter quais valores e variáveis ​​dentro calforam usados ​​para criar o gráfico? O que está acontecendo por baixo?

Para este exemplo específico, posso ver que uma dica pode ser dada pela existência da seção cal$plot; no entanto, ainda não consigo entender quais variáveis ​​foram usadas e quais funções foram aplicadas aos valores armazenados ali para finalmente poder criar o gráfico.

Recebi um conjunto de dados em que os nomes das colunas são números, como este:

df<- data.frame(firstvar = c(1:5),
                secondvar = c(15:19))
colnames (df) <- c(1000, 1500)

df

  1000 1500
1    1   15
2    2   16
3    3   17
4    4   18
5    5   19

Eu sei que preciso usar aspas para chamar cada coluna:

 df$`1000`
 [1]  1  2  3  4  5

Gostaria de usar o objeto N(que será um argumento em uma função no meu programa real) e atribuí-lo ao nome da coluna (numérica) para que eu pudesse usá-lo em vez de digitar manualmente '1000'. No entanto, não consigo fazer funcionar, pois recebo NULL como saída.

O que eu tentei (sempre obtive NULL como resultado):

N <- 1000

df$`N`
df$N
df$'N'

Como eu gostaria que funcionasse:

N <- 1000

df$`N`
[1]  1  2  3  4  5

Isso é possível?

Estou traçando um mapa da Europa com ggplot2e gostaria de mostrar meridianos e paralelos. Posso fazer isso usando panel.grid.majore panel.grid.minor.

Entretanto, com meu código atual, a grade criada com ggplot fica em segundo plano em comparação à superfície plotada (os países), de modo que quando os dois se sobrepõem, a grade não pode ser vista:

library(rnaturalearth)
library(ggplot2)
library(sf)


ggplot(ne_countries(scale = "medium", continent = NULL, returnclass = "sf")) +
  geom_sf() +
  coord_sf(xlim=c(2600000, 7300000), ylim=c(5450000, 1000000), 
           crs = st_crs(3035)) +
  theme(panel.background = element_rect(fill = "white"),
        panel.grid.major = element_line(colour = "red"),
        panel.grid.minor = element_line(colour = "red"))

Isso não é o ideal, pois eu gostaria de sempre ver meridianos e paralelos, mesmo quando se sobrepõem às geometrias dos países.

Existe uma maneira de deixar a grade em primeiro plano e a superfície plotada em segundo plano ggplot2?

Tenho um conjunto muito simples de funções que pegam uma variável de caractere de entrada (uma palavra ou frase) e retornam uma nova. Basicamente, cada uma dessas funções realiza uma criptografia diferente na palavra de entrada.

Como tanto a entrada quanto a saída dessas funções são variáveis ​​de caracteres, a saída de uma função pode ser usada como entrada para outra, de modo que várias cifras sequenciais podem ser aplicadas. Por exemplo:

#install.packages("ciphertext")
library(ciphertext)

first_output <- ciphertext::caesar("hello"); first_output

[1] "ifmmp"

ciphertext::atbash(first_output)

[1] "runnk"

Eu queria saber se existe a possibilidade em R de criar uma função (que nomeei combinefabaixo) que recebe como entrada uma variável de caractere inicial ("olá", no meu exemplo) e aplica sequencialmente outras funções listadas como argumentos adicionais.

Então o algoritmo seria algo como:

1. Pegue a palavra inicial ("olá")
2. Aplique a primeira função listada à palavra inicial e obtenha uma nova palavra
3. repita o passo 1 com a nova palavra até usar todos os argumentos listados

Como eu gostaria que funcionasse e o resultado final esperado:

combinef("hello", caesar, atbash) #apply caesar function to "hello", and then atbash
[1] "runnk"


combinef("hello", caesar, atbash, polybius) #apply polybius after the atbash
"42 45 33 33 25"

Todas as minhas tentativas de criar tal função são extremamente prolixas, pois tentei fazer uso de if (argument2 == "function_name")estruturas, mas isso se tornou impraticável quando o número de métodos de cifragem potenciais aumentou.

Qualquer ajuda ou sugestão será muito apreciada!

Estou escrevendo uma função para cifrar pequenas frases e acabo tendo a frase inicial ( w0) e sua versão criptografada ( w1).

Gostaria de inserir ambos w0e w1em um objeto que é retornado pela função, e atualmente estou fazendo isso usandolist()

Entretanto, se eu salvá-lo em um objeto (chamado TEST no código) e depois chamá-lo, tanto a frase inicial quanto a criptografada são impressas, o que não é o ideal para mim.

Gostaria de ter a possibilidade de salvar a saída em um objeto que, quando chamado ingenuamente, mostre apenas o primeiro elemento (a palavra inicial), com a possibilidade de imprimir o segundo quando necessário especificamente, talvez usando $.

Isso é possível? Obrigado!

Minha função atual comlist()

cipher <- function(word){

  w0 <- tolower(unlist(strsplit(word, "")))
  w1 <- c()
  shuffledletters <- sample(letters)
  
  for (i in (1:length(w0))) {
    w1[i] <- ifelse(w0[i] %in% letters,
                    shuffledletters[which(w0[i]==letters)], " ")
  }

out <- list(w0,w1)
return(out)
}

O que eu ganho agora:

TEST <- cipher("hello world")
TEST

[[1]]
 [1] "h" "e" "l" "l" "o" " " "w" "o" "r" "l" "d"

[[2]]
 [1] "p" "s" "r" "r" "a" " " "y" "a" "j" "r" "m"

O que eu gostaria de ter como saída (sei que com listas isso não é possível)

TEST
 [1] "h" "e" "l" "l" "o" " " "w" "o" "r" "l" "d"

TEST$initial
 [1] "h" "e" "l" "l" "o" " " "w" "o" "r" "l" "d"

TEST$encrypted
 [1] "p" "s" "r" "r" "a" " " "y" "a" "j" "r" "m"