Assistente para ajuste de modelos de degradação in situ e produção de gases

blog13

           As técnicas de digestibilidade in situ e produção de gases, são bastante utilizadas na nutrição de ruminantes para se avaliar o valor dos alimentos. Estas técnicas permitem estimar a taxa de degradação dos alimentos no ambiente ruminal e quando associado a um marcador, que nos forneça informações sobre a taxa de passagem, podemos estimar a degradabilidade ruminal do alimento.

             Os principais modelos utilizados para ajustar o desaparecimento ruminal do alimento ao longo do tempo ou a produção cumulativa de gases ao longo do tempo são funções não lineares. A solução para estimativa dos parâmetros nesta funções somente pode ser obtido por métodos numéricos , seguindo procedimentos te otimização interativas. Procedimentos de otimização interativas exigem que o analista forneça os valores iniciais dos parâmetros e após sucessivas interações os parâmetros vão sendo ajustados de tal forma que a soma de quadrados dos resíduos (SQR) é reduzida em cada passo. O critério de convergência será atendido quando a SQR atingir valor mínimo ( ou máxima probabilidade da variável resposta for obtida), a partir deste ponto nenhuma melhora no ajuste do modelo é possível através dos parâmetros.

            Os valores iniciais devem ser próximos aos valores desconhecidos dos parâmetros que serão estimados ou o procedimento de otimização pode não convergir. Além disso valores iniciais inadequados podem levar o algoritmo a convergir para um minimo local ao invés do minimo global, esperado na estimativa dos quadrados mínimos.

            No post de hoje apresento um assistente útil no processo de ajuste de modelos não lineares, para análise de experimentos de digestibilidade in situ e produção de gasses. Este assistente é uma extensão do script fornecido pelo Prof. Walmes em seu blog Ridículas que modifiquei para trabalhar com vários modelos. O código depende dos pacotes Rpanel e nlme estarem instalados em seu sistema. Os modelos utilizados foram descritos nos trabalhos de López et al (1999) e France et al (2000) para modelos de digestibilidade in situ e produção de gases respectivamente. Segue algumas observações para seu uso: (veja vídeo)

a) Para utilizar este assistente os dados devem estar no formato CSV (separado por vírgula);
b) Pare selecionar subgrupos de dados escreva uma expressão logical indicando qual subgrupo de dados selecionar (não usar aspas)
p.ex: dieta==1 & concentracao==10 para selecionar os dados identificados por dieta==1 e concentração igual a 10 ; dieta==2 | dieta ==4 & concentracao==40 para selecionar dietas identificados por 2 ou 4 e concentração igual a 40, veja manual da função gnls {nlme} para mais informações.

c) Nas caixas “nome da variável dependente (y)” e ” nome da variável independente (x)” insira o nome das variáveis dependente e independente conforme encontra-se em seu banco de dados importado.

d) Ao clicar em ajustar uma curva de cor azul será sobreposta ao gráfico, para indicar convergência. Quando não houver convergência uma mensagem será apresentada sobre o gráfico. Quando outro motivo, além do limite para critério de convergência, gerar erro nenhuma mensagem ou curva na cor azul será mostrada e a mensagem de erro/warnings pode ser vista no console;

e) Clique em ajustar para ver o modelo ajustado sobre o R console (equivalente a digitar “summary(modelo))

f) O modelo Gompertz para produção de gases onde são fornecidos dois modelos Gompertz I e Gompertz II esses modelos diferem quanto ao ponto de inflexão da curva: Ambos os modelos não são simétricos sobre o ponto de inflexão M. Para o modelo Gompertz I M é obtido da fórmula K = exp [–exp (cM)] e para Gompertz II M=(1/c)*ln(c/b). Veja France et al 2000 e López (2008) (cap 3 , pag. 55) para mais detalhes

até a proxima dica!


#Baixe o arquivo em algum diretório em seu computador
# Em "destfile=" coloque o endereço do diretório onde deseja salvar o arquivo

Windows
download.file("https://www.dropbox.com/s/el82xcu4fft3tpg/gases.csv?raw=1",destfile="c:\Users\(username)\Desktop\gases.csv")

Linux 
download.file("https://www.dropbox.com/s/el82xcu4fft3tpg/gases.csv?raw=1",destfile="~/Área de trabalho/gases.csv")

#================================================
# Interface gráfica para ajuste de modelos de digestibilidade in situ e produção de gases
# Autor: Fernando Souza
# Data: 22/04/2016
#================================================
#--------Verifica se os pacotes necessários estão instalados e instala-os em caso negativo--------

packages <- c("rpanel","nlme") # Verifica se os pacotes necessários estão instalados, em caso negativo faz a instalação if (length(setdiff(packages, rownames(installed.packages()))) > 0) {
install.packages(setdiff(packages, rownames(installed.packages())))
}

# ativa os pacotes necessários
for (i in 1:length(packages)){
library(packages[i],character.only = TRUE)
print(paste("O seguinte pacote foi carregado:",packages[i],sep=""))
}

#-------------------------Seleciona o banco de dados---------------------
#------------banco dados deve ser salvo como csv-------------------------
database<-function(panel){
dados<<-read.csv(file.choose(), header=TRUE)
print(head(dados));
return(panel)
}
#Altera o nome da variável dependente e independente definida pelo usuário para y e x
ren_y<-function(panel){
var_dep<<-panel$var_y
colnames(dados)[grep(var_dep,colnames(dados))]<<-"y"
print(colnames(dados)); return(panel)}

ren_x <- function(panel){
var_indep<<-panel$var_x
colnames(dados)[grep(var_indep,colnames(dados))]<<-"x"
print(colnames(dados)); return(panel)}

#================================================#-----------------Ajusta os modelos de degradabilidade in situ e produção de gases------------------
#---Referencias in situ: Lopez et al,(1999); produção gases : France et al  (2000)----------------
#================================================
#nlsajust é excutada quando clicar no botão "Ajustar"

nlsajust <- function(panel){
## ajuste do modelo não linear
controle<<-nlmeControl(nlmStepMax=1000,nlsTol=0.01,maxIter=100)
if(panel$modelo == "Orskov & McDonald"){
n0 <<- try(gnls(y~a+b*(1-exp(-c*(x-d))), # modelo de Orskov & McDonanld (1979)
data=da,control=controle,na.action=na.omit,
start=start),)
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a+b*(1-exp(-c*(x-d))),
add=TRUE, col="blue"))
aju <<- n0
}

}
if(panel$modelo=="Michaelis-Menten"){
n0 <<- try(gnls(y~a+b*((x-d)/(x-d+c)), # modelo Michaelis-Menten (ou Inversa Polinomial)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a+b*((x-d)/(x-d+c)),
add=TRUE, col="blue"))
aju <<- n0
}

}
if(panel$modelo=="Van Milgen"){
n0 <<- try(gnls(y~a+b*(1-((c*exp(-d*x)-d*exp(-c*x))/(c-d))), # modelo lag compartimental (Van Milgen et al (1991)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a+b*(1-((c*exp(-d*x)-d*exp(-c*x))/(c-d))),
add=TRUE, col="blue"))
aju <<- n0
}
}
if(panel$modelo=="France"){
n0 <<- try(gnls(y~a+b*(1-exp(-c*(x-e)-d*(sqrt(x)-sqrt(e)))), # Modelo Generalized Mitscherlich Dhanoa et al (1995)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a+b*(1-exp(-c*(x-e)-d*(sqrt(x)-sqrt(e)))),
add=TRUE, col="blue"))
aju <<- n0
}
}
if(panel$modelo=="Michaelis-Menten Generalizado"){
n0 <<- try(gnls(y~a+b*((x^c)/((x^c)+(d^c))), # modelo Michaelis-Menten Generalizado (France et al,1998)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a+b*((x^c)/((x^c)+(d^c))),
add=TRUE, col="blue"))
aju <<- n0
}
}
if (panel$modelo=="Inversa Exponencial"){
n0 <<- try(gnls(y~a+b*((1-exp(-c*x))/(1+d*exp(-c*x))), # modelo inversa exponencial (France et al,1990)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a+b*((1-exp(-c*x))/(1+d*exp(-c*x))),
add=TRUE, col="blue"))
aju <<- n0
}
}
if(panel$modelo=="Gompertz I"){
n0 <<- try(gnls(y~a+b*((d-d^exp(-c*x))/(d-1)),
# Gompertz curve, asymmetrical about an inflection point M, # which can be calculated from K = exp[−exp (cM)] (France et al., 1990)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a+b*((d-d^exp(-c*x))/(d-1)),
add=TRUE, col="blue"))
aju <<- n0
}
}

if(panel$modelo=="Von Bertallanffy"){
n0 <<- try(gnls(y~a+b*((1-exp(-c*x))^1/d), # modelo Von Bertallanfy (Ricker,1979)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a+b*((1-exp(-c*x))^1/d),
add=TRUE, col="blue"))
aju <<- n0
}

}
if(panel$modelo == "PG-Oskov & McDonald"){
n0 <<- try(gnls(y~a*(1-exp(-c*(x-b))), # modelo Oskov & McDonald (1979)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a*(1-exp(-c*(x-b))),
add=TRUE, col="blue"))
aju <<- n0
}

}
if(panel$modelo=="PG-Michaelis-Menten"){
n0 <<- try(gnls(y~a*((x-b)/(x-b+c)), # modelo Michaelis-Menten
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a*((x-b)/(x-b+c)),
add=TRUE, col="blue"))
aju <<- n0
}

}
if(panel$modelo=="PG-Van Milgen"){
n0 <<- try(gnls(y~a*(1-((c*exp(-b*x)-b*exp(-c*x))/(c-b))), # modelo Van Mingen et al (1991)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a*(1-((c*exp(-b*x)-b*exp(-c*x))/(c-b))),
add=TRUE, col="blue"))
aju <<- n0
}
}
if(panel$modelo=="PG-France"){
n0 <<- try(gnls(y~a*(1-exp(-c*(x-d)-b*(sqrt(x)-sqrt(d)))), # modelo Mitscherlich (France 2000)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a*(1-exp(-c*(x-d)-b*(sqrt(x)-sqrt(d)))),
add=TRUE, col="blue"))
aju <<- n0
}
}
if(panel$modelo=="PG-Michaelis-Menten Generalizado"){
n0 <<- try(gnls(y~a*((x^c)/((x^c)+(b^c))), # modelo Michaelis-Menten Generalizado (France,2000)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a*((x^c)/((x^c)+(b^c))),
add=TRUE, col="blue"))
aju <<- n0
}
}
if (panel$modelo=="PG-Inversa Exponencial"){
n0 <<- try(gnls(y~a*((1-exp(-c*x))/(1+b*exp(-c*x))), # modelo inversa exponencial
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a*((1-exp(-c*x))/(1+b*exp(-c*x))),
add=TRUE, col="blue"))
aju <<- n0
}
}
if(panel$modelo=="PG-Gompertz I"){
#Modelo Gompertz, non-symmetrical about an inflection point M, which can be calculated from
#K = exp [–exp (cM)]
n0 <<- try(gnls(y~a*((b-b^exp(-c*x))/(b-1)),
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a*((b-b^exp(-c*x))/(b-1)),
add=TRUE, col="blue"))
aju <<- n0
}
}

if(panel$modelo=="PG-Gompertz II"){
#Modelo Gompertz, non-symmetrical about an inflection point M=(1/c)*ln(c/b)
n0 <<- try(gnls(y~a*((1-exp((-b/c)*(exp(c*x)-1)))), # modelo Gompertz II
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a*((1-exp((-b/c)*(exp(c*x)-1)))),
add=TRUE, col="blue"))
aju <<- n0
}

}

if(panel$modelo=="Von Bertalanffy"){
n0 <<- try(gnls(y~a*((1-exp(-c*x))^1/b), # modelo Von Bertalanffy modificado
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a*((1-exp(-c*x))^1/b),
add=TRUE, col="blue"))
aju <<- n0
}

}
panel
}

#================================================#--------------------------Seleciona subgrupo dos dados--------------------------------------------------------
#================================================
subgrupo <- function(panel){


if(panel$grupo ==""){
da<<-dados
} else{

da <<- subset(dados,subset=eval(parse(text=panel$grupo)))

}
return(panel)
}

#================================================
#--Função que cria o gráfico,e sobrepoe a curva sobre os pontos quando os sliders são #deslizados.
#================================================
vg <- function(panel){

if (panel$modelo == "Orskov & McDonald"|panel$modelo=="Michaelis-Menten"|panel$modelo=="Van Milgen"|panel$modelo=="Michaelis-Menten Generalizado"|panel$modelo=="Inversa Exponencial"|panel$modelo=="Gompertz I"|panel$modelo=="Von Bertalanffy"){

start <<-panel[c("a","b","c","d")]
}
if (panel$modelo =="France"){
## lista com valores iniciais vindos dos deslizadores
start <<- panel[c("a","b","c","d","e")]
}
if (panel$modelo == "PG-Orskov & McDonald"|panel$modelo=="PG-Michaelis-Menten"|panel$modelo=="PG-Van Milgen"|panel$modelo=="PG-Michaelis-Menten Generalizado"|panel$modelo=="PG-Inversa Exponencial"|panel$modelo=="PG-Gompertz I"|panel$modelo=="PG-Gompertz II"|panel$modelo=="PG-Von Bertalanffy"){

start<<-panel[c("a","b","c")]
}
if(panel$modelo=="PG-France"){

start<<-panel[c("a","b","c","d")]

}

par(mar=c(4.1,4.2,3.1,1))
with(da,plot(x,y,ylab= var_dep,xlab=var_indep))

if(panel$modelo =="Orskov & McDonald"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a+b(1-exp(-c*(x-d)))')))
with(start, curve(a+b*(1-exp(-c*(x-d))),
add=TRUE, col=2, lty=2))}

if(panel$modelo=="Michaelis-Menten"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a+b((x-d)/(x-d+c))')))
with(start, curve(a+b*((x-d)/(x-d+c)),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="Van Milgen"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a+b(1-((c*exp(-c*x))/(c-d)))')))
with(start, curve(a+b*(1-((c*exp(-d*x)-d*exp(-c*x))/(c-d))),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="France"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a+b(1-exp(-c*(x-e)-d*(sqrt(x)-sqrt(e))))')))
with(start, curve(a+b*(1-exp(-c*(x-e)-d*(sqrt(x)-sqrt(e)))),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="Michaelis-Menten Generalizado"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a+b((x^c)/((x^c)+(d^c)))')))
with(start, curve(a+b*((x^c)/((x^c)+(d^c))),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="Inversa Exponencial"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a+b((1-exp(-c*x))/(1+d*exp(-c*x)))')))
with(start, curve(a+b*((1-exp(-c*x))/(1+d*exp(-c*x))),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="Gompertz I"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a+b((d-d^exp(-c*x))/(d-1))')))
with(start, curve(a+b*((d-d^exp(-c*x))/(d-1)),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="Von Bertalanffy"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a+b((1-exp(-c*x))^1/d)')))
with(start, curve(a+b*((1-exp(-c*x))^1/d),
add=TRUE, col=2, lty=2))}
if(panel$modelo =="PG-Orskov & McDonald"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a(1-exp(-c*(x-b)))')))
with(start, curve(a*(1-exp(-c*(x-b))),
add=TRUE, col=2, lty=2))}

if(panel$modelo=="PG-Michaelis-Menten"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a((x-b)/(x-b+c))')))
with(start, curve(a*((x-b)/(x-b+c)),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="PG-Van Milgen"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a(1-((c*exp(-b*x)-b*exp(-c*x)/(c-b)))')))
with(start, curve( a*(1-((c*exp(-b*x)-b*exp(-c*x))/(c-b))),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="PG-France"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a(1-exp(-c*(x-d)-b*(sqrt(x)-sqrt(d))))')))
with(start, curve(a*(1-exp(-c*(x-d)-b*(sqrt(x)-sqrt(d)))),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="PG-Michaelis-Menten Generalizado"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a*((x^c)/((x^c)+(b^c)))')))
with(start, curve(a*((x^c)/((x^c)+(b^c))),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="PG-Inversa Exponencial"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a*((1-exp(-c*x))/(1+b*exp(-c*x)))')))
with(start, curve(a*((1-exp(-c*x))/(1+b*exp(-c*x))),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="PG-Gompertz I"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a*((b-b^exp(-c*x))/(b-1))')))
with(start, curve(a*((b-b^exp(-c*x))/(b-1)),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="PG-Gompertz II"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a*((1-exp((-b/c)*(exp(c*x)-1))))')))
with(start, curve(a*((1-exp((-b/c)*(exp(c*x)-1)))),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="PG-Von Bertalanffy"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a*((1-exp(-c*x))^1/b)')))
with(start, curve(a*((1-exp(-c*x))^1/b),
add=TRUE, col=2, lty=2))}

return(panel)
}

#================================================
#----------------mostra o resultado quando o botão ver ajuste é acionado----------------------
#================================================
verajust <- function(panel){
a<-summary(aju)
print(a)
panel
}

# cria objetos vazios que serão preenchidos durante processo
da <- c(); start <- list();
#================================================
# Gera a interface gráfica para trabalho
#================================================
panel <- rp.control()
#botão para importar banco de dados
rp.button(panel, action=database,foreground="black",background = "orange",title="IMPORTAR DADOS")
# Obtem os
#nomes das variáveis dependentes
rp.textentry(panel=panel, variable=var_y,width = 10,foreground = "black", background = "gray87",
labels="NOME DA VARIÁVEL DEPENDENTE (y):",
initval="",
action=ren_y)

rp.textentry(panel=panel, variable=var_x,width=10,foreground = "black", background = "gray87",
labels="NOME DA VARIÁVEL INDEPENDENTE(x):",
initval="",
action=ren_x)
rp.textentry(panel,variable=grupo,initval="",labels="SUBGRUPO DE DADOS", ,
foreground = "black",background="gray87",action=subgrupo)

models_name<<- c("--Modelos Dig. in Situ--","Orskov & McDonald","Inversa Polinomial","Van Milgen","France","Michaelis-Menten Generalizado","Inversa Exponencial","Gompertz I","Von Bertalanffy","--Modelos Prod. Gases--","PG-Orskov & McDonald","PG-Michaelis-Menten","PG-Van Milgen","PG-France","PG-Michaelis-Menten Generalizado","PG-Inversa Exponencial","PG-Gompertz I","PG-Gompertz II","PG-Von Bertalanffy")

mod_id<<- c("--Modelos Dig. in situ--","MOD1","MOD2","MOD3","MOD4","MOD5","MOD6","MOD7","MOD8","---Modelos Prod. Gases---","PG1","PG2","PG3","PG4","PG5","PG6","PG7","PG8","PG9")

rp.listbox(panel,modelo, vals=models_name,rows=5,title="Modelos",foreground = "black",background="gray87",action=vg)

rp.text(panel,"Parâmetros do modelo")

# controla parâmetros do modelo

rp.slider(panel, a,0.001,100.001, initval=50.001,foreground="black",background="gray87", title="a", showvalue=TRUE,showvaluewidth=4, action=vg)
rp.slider(panel, b,-5.001,5.001, initval=0.001,foreground="black",background="gray87",title="b", showvalue=TRUE,showvaluewidth=4, action=vg)
rp.slider(panel, c, -1.001,1.001, initval=0.001,foreground="black",background="gray87",title="c", showvalue=TRUE,showvaluewidth=4, action=vg)
rp.slider(panel, d, -2.001,2.001, initval=0.001,foreground="black",background="gray87", title="d", showvalue=TRUE,showvaluewidth=4, action=vg)
rp.slider(panel, e, 0.001,5.001, initval=2.5,foreground="black",background="gray87",title="e", showvalue=TRUE,showvaluewidth=4, action=vg)

# cria botão "Ajustar"
rp.button(panel, action=nlsajust,foreground="black",background = "orange", title="AJUSTAR")
rp.button(panel, action=verajust,foreground="black",background="springgreen",title="VER AJUSTE")


#================================================
Publicado em Experimentos, Regressões | Marcado com , , , , , , | 2 Comentários

Nova Versão do Rstudio liberada

RStudio-BallOs desenvolvedores do editor Rstudio anunciaram a liberação da versão v0.99.878  do  editor . O novo editor está disponível para download na página do Rstudio. O Rstudio é um dos mais utilizados editores R. A nova versão veio repleta de novidades . Um resumo é apresentado abaixo. Mais informações podem ser obtidas aqui

RStudio Addins

Fornece um meio de executar suas funções R interativamente de dentro do Rstudio (através de atalho de teclado ou através do addins menu) . Usuários podem agora escrever código R para interagir e modificar os conteúdos dos documentos abertos. Veja um exemplo do seu uso:

Você pode aprender mais sobre addins no site: http://rstudio.github.io/rstudioaddins/.

subset-addin

R Markdown

Melhoramentos para  utilização do R Markadown. Há agora uma opcional janela que permite a rápida navegação através de grandes documentos

Screen Shot 2015-12-22 at 9.27.34 AM

Adição em linha de interface de usuário para códigos chunks do knitr para rodar individual chunks, executar previous chunks e especificar opções knit comumente utilizada

Screen Shot 2015-12-22 at 9.30.11 AM

Múltipla janela de código:

Existência de duas formas de abrir uma nova janela de código:

Pop out an editor:

Tear off a pane:

Atalhos de teclado personalizáveis

Você pode customizar atalhos de teclado para executar comando de aplicações do Rstudio, comandos do editor ou de funções definidas pelo usuário.

Clique em:  ferramentas -> Modifique atalhos de teclado...:

Atalhos de teclado Emacs

  • C-p, C-n, C-b and C-f to move the cursor up, down left and right by characters
  • M-b, M-f to move left and right by words
  • C-a, C-e to navigate to the start, or end, of line;
  • C-k to ‘kill’ to end of line, and C-y to ‘yank’ the last kill,
  • C-s, C-r to initiate an Emacs-style incremental search (forward / reverse),
  • C-Space to set/unset mark, and C-w to kill the marked region.

Adicionais atalhos do Emacs Speaks Statistics (ESS) :

  • C-c C-v displays help for the object under the cursor,
  • C-c C-n evaluates the current line / selection,
  • C-x b allows you to visit another file,
  • M-C-a moves the cursor to the beginning of the current function,
  • M-C-e moves to the end of the current function,
  • C-c C-f evaluates the current function.

Atalhos que permite interagir como o IDE como normalmente é feito em Emacs

  • C-x C-n to create a new document,
  • C-x C-f to find / open an existing document,
  • C-x C-s to save the current document,
  • C-x k to close the current file
Publicado em Regressões | Deixe um comentário

Arvore de Natal com o R

arvorenatalÉ sempre bom descobrir o quanto o R é poderoso! Gosto  de acompanhar outros blogs e observar o quanto os usuários R desenvolvem idéias  utilizando essa ferramenta. Isso me inspira a aprender cada vez mais sobre o software.

No post de hoje, aproveito a proximidade do natal para  compartilhar   a árvore  criada por Kees Duineveld  e publicada no blog  Wiekvoet . Essa arvore apresenta uma riqueza de detalhes  e  mostra o quanto o R dinâmico.  Espero que ela  possa inspirar vocês a progredir em seus estudos.

Desejo a todos um feliz natal e um 2016 repleto de realizações.


part <- list(x0=0,y0=0,x1=0,y1=1,
branch1=NULL,branch2=NULL,extend=NULL,
lwd=1,depth=0,col="springgreen")

par(mfrow=c(1,1),mar=c(5, 4, 4, 2) + 0.1)

segplot <- function(tree) {
if (is.null(tree)) return()
segments(tree$x0,tree$y0,tree$x1,tree$y1,
col=tree$col,
lwd=tree$lwd)
segplot(tree$branch1)
segplot(tree$branch2)
segplot(tree$extend)
}
#--------------------------------segplot(part)---------------------------------------
<p style="text-align: left;">grow <- function(tree) {
if (is.null(tree) ) return(NULL)

tree$lwd=tree$lwd*1.2

if (tree$lwd>2.5) tree$col <- "brown"
if (is.null(tree$extend)) {
tree$extend <- list(
x0=tree$x1,
y0=tree$y1,
x1=rnorm(1,1,.03)*(2*tree$x1-tree$x0),
y1=(rnorm(1,.98,.02)+.02*(tree$x1==tree$x0))*(2*tree$y1-tree$y0),
branch1=NULL,
branch2=NULL,
extend=NULL,
lwd=1,
depth=tree$depth,
col=tree$col
)
length=sqrt((tree$x1-tree$x0)^2 + (tree$y1-tree$y0)^2)
angle <- asin((tree$x1-tree$x0)/length)
branch <- list(
x0=(tree$x1+tree$x0)/2,
y0=(tree$y1+tree$y0)/2,
branch1=NULL,
branch2=NULL,
extend=NULL,
lwd=1,
depth=tree$depth,
col=tree$col
)
shift <- rnorm(2,.5,.1)
branch$x0 <- shift[1]*tree$x1+(1-shift[1])*tree$x0
branch$y0 <- shift[1]*tree$y1+(1-shift[1])*tree$y0
length=length*rnorm(1,.5,.05)
co <- runif(1,.35,.45)
branch$x1 <- branch$x0+sin(angle+co)*length
branch$y1 <- branch$y0+cos(angle+co)*length
tree$branch1 <- branch
branch$x0 <- shift[2]*tree$x1+(1-shift[2])*tree$x0
branch$y0 <- shift[2]*tree$y1+(1-shift[2])*tree$y0
co <- runif(1,.35,.45)
branch$x1 <- branch$x0+sin(angle-co)*length
branch$y1 <- branch$y0+cos(angle-co)*length
tree$branch2 <- branch
} else {
tree$branch1 <- grow(tree$branch1)
tree$branch2 <- grow(tree$branch2)
tree$extend <- grow(tree$extend)
}
tree$depth <- tree$depth+1
if (tree$depth>2) tree$col <- "green"
if (tree$depth>4) tree$col <- "darkgreen"
if (tree$depth>6) tree$col <- "brown"

tree
}
tree <- part
for (i in 1:9) tree <- grow(tree)</p>
#-------------determina o local onde salvar a imagem ---------------

#setwd("~/Documentos/ProjetosR")#usuários linux

#---------------------------------------------------------------------------------------

setwd("c:/Documentos/minhapasta") #usuários windows
png(filename="arvorenatal.png")
par(mar=c(0,0,0,0))
plot(x=c(-3,3),y=c(0,9),type="n",axes=FALSE,xlab="",ylab="")
segplot(tree)
dev.off()
Publicado em Aplicacao | Marcado com , | Deixe um comentário

Livros R gratuitos para download

54645555O software R é uma poderosa ferramenta para a realização análises de dados.  Por ser o R um ambiente de programação, praticamente toda análise pode ser realizada utilizando as ferramentas disponíveis no pacote base ou utilizando as ferramentas disponíveis nas centenas de pacotes desenvolvidos por voluntários ao redor do mundo e disponibilizado no CRAN.  Aquilo que ainda não foi implementado poderá ser implementado e distribuído aos demais usuários ao redor do mundo.

O desenvolvimento em R entretanto exige estudo e uma constante atualização para que o usuário tire o máximo de proveito de suas funcionalidades. Para isso o R conta com um vasto número de publicações (1 , 2) na forma de livros, tutoriais,  apresentações, conteúdos on line, vídeos, etc. Muito destas publicações são disponibilizadas para downloada gratuitamente pelos seus autores o que torna mais fácil a compreensão da linguagem R aplicada a análises específicas.

No post de hoje disponibilizo vários links para diversos materiais sobre o software R (livros, tutoriais, apresentações, sites) que foram disponibilizados ,gratuitamente, pelos seus autores. Esta é entretanto uma lista parcial e novas atualizações ocorrerão. Caso conheça algum material e queiram compartilha-lo aqui no blog, deixe uma mensagem.

Bom estudo!

  1. Introduction to probability and statistics using R : https://cran.r-project.org/web/packages/IPSUR/vignettes/IPSUR.pdf
  2.  An introduction to R: https://cran.r-project.org/doc/manuals/R-intro.pdf
  3. The art of R programming: http://heather.cs.ucdavis.edu/~matloff/132/NSPpart.pdf
  4. A little book of r for multivariate analysis: https://media.readthedocs.org/pdf/little-book-of-r-for-multivariate-analysis/latest/little-book-of-r-for-multivariate-analysis.pdf
  5. Introduction to statistical learning with application in R: http://www-bcf.usc.edu/~gareth/ISL/ISLR%20First%20Printing.pdf
  6. Statistical foundations of machine learning: https://www.otexts.org/book/sfml (disponível para leitura on line)
  7. Advanced R: http://adv-r.had.co.nz/ (disponível para leitura on line)
  8. The elementals of statistical learning: http://statweb.stanford.edu/~tibs/ElemStatLearn/printings/ESLII_print10.pdf
  9. An Introduction to R:Software for Statistical Modelling & Computing: http://cran.r-project.org/doc/contrib/Kuhnert+Venables-R_Course_Notes.zip
  10. Using r for data analysis and graphics: https://cran.r-project.org/doc/contrib/usingR.pdf
  11. R for SAS and SPSS users: https://docs.google.com/viewer?a=v&pid=sites&srcid=ZGVmYXVsdGRvbWFpbnxyNHN0YXRpc3RpY3N8Z3g6MWNmZDQ4ZjcwODY2Y2I0Yw
  12. The r guide: https://cran.r-project.org/doc/contrib/Owen-TheRGuide.pdf
  13. Introduction to r project for statistical computing for use in ITC: https://cran.r-project.org/doc/contrib/Rossiter-RIntro-ITC.pdf
  14. R for beginners: https://cran.r-project.org/doc/contrib/Paradis-rdebuts_en.pdf
  15. R tips: http://pj.freefaculty.org/R/Rtips.pdf
  16. Introduction to Probability and Statistics Using R: http://download.savannah.gnu.org/releases/ipsur/
  17. Statistics with R : http://zoonek2.free.fr/UNIX/48_R/all.html
  18. R programming : https://en.wikibooks.org/wiki/R_Programming
  19. R inferno : http://www.burns-stat.com/pages/Tutor/R_inferno.pdf
  20. The undergraduate guide to R : https://sites.google.com/site/undergraduateguidetor/manual-files
  21. Simply R: https://cran.r-project.org/doc/contrib/Verzani-SimpleR.pdf
  22. Practical Regression and Anova in R: http://www.maths.bath.ac.uk/~jjf23/book/
  23. Introduction to Statistical Thinking : http://pluto.huji.ac.il/~msby/StatThink/index.html
  24. A little e-book of r for biomedical statistics: http://a-little-book-of-r-for-biomedical-statistics.readthedocs.org/en/latest/index.html
  25. Introdução ao uso do programa R : https://cran.r-project.org/doc/contrib/Landeiro-Introducao.pdf
  26. introdução à Linguagem R para Pós-Graduandos em Ecologia: http://ecologia.ib.usp.br/bie5782/doku.php?id=start
  27. Introdução ao ambiente estatístico R : http://www.leg.ufpr.br/~paulojus/embrapa/Rembrapa/Rembrapa.pdf
  28. Curso de introdução a R: http://www.iesc.ufrj.br/cursos/bioestatistica/topicosanalisedadosII_R/AULA%20R%20IESC%202011%2002.pdf
  29. Minicurso de estatística básica-Introdução ao R: http://www.uft.edu.br/engambiental/prof/catalunha/arquivos/r/r_bruno.pdf
  30. Introdução ao ambiente computacional R: http://www.ufscar.br/~des/docente/josemar/152056/05082008/tutoport-apostilaR_monitoria.pdf
  31. Introdução a estatística básica com R: http://www.quintiliano.prof.ufu.br/index_arquivos/EBR.pdf
  32. Tópicos de estatística com R : https://cran.r-project.org/doc/contrib/Itano-descriptive-stats.pdf
  33. Estatística aplicada a ecologia usando R : https://cran.r-project.org/doc/contrib/Provete-Estatistica_aplicada.pdf
  34. Laboratório de estatística e geoinformação da UFPR : http://www.leg.ufpr.br/doku.php/sofware:material-r
  35. Simpósio de estatística aplicada a experimentação agronômica : http://sigeve.ead.unesp.br/paginas/din.php?p=101
  36. Curso de capacitação no ambiente R : http://www.leg.ufpr.br/~walmes/cursoR/cursoR4.pdf
Publicado em Livros | Marcado com | Deixe um comentário

R Versão 3.2.3 liberada

RlogoNo último dia 10/12/2015 foi liberada a nova versão do R. A versão 3.2.3, codenome “Wooden Christmas-Tree” (árvore natal de madeira) as principais alterações podem ser acessadas na página do r-announce, feitas por Peter Dalgaard.

Usuários Windows podem atualizar seu sistema com o código abaixo:

if(!require(installr)) {install.packages("installr"); require(installr)}updateR()

Usuários linux devem incluir em sua sources.list (/etc/apt/sources.list) os seguintes diretórios de acordo com sua distro e  versão. Inclua seu favorito cran mirror no local indicado.

#Ubuntu wily:

deb https://<my.favorite.cran.mirror>/bin/linux/ubuntu wily/

#Ubuntu vivid

deb https://<my.favorite.cran.mirror>/bin/linux/ubuntu vivid/

#Ubuntu trusty

deb https://<my.favorite.cran.mirror>/bin/linux/ubuntu trusty/

#Debian Jessie

deb http://<favourite-cran-mirror>/bin/linux/debian jessie-cran3/

Abra o terminal e digite

 sudo apt-get update 

ou utilize o utilitário de atualização de pacotes existentes em sua distro.

OBS:

Por ser uma liberação recente pode ocorrer que a nova versão ainda não  esteja disponível em seu cran mirror, e neste caso a atualização não ocorrerá. Neste caso você pode mudar o seu cran mirror, aguardar a inclusão no CRAN mirror ou baixar e instalar o diretamente do cran da seguinte forma

baixe o arquivo R-3.2.2.tar.gz do CRAN para algum local em seu computador. Você pode se orientar por  Aqui 

Publicado em R Notícias | Marcado com , | Deixe um comentário

Entendendo o uso das funções apply, lapply, sapply, tapply, mapply

use apply        A família Apply representa um conjunto de funções básicas do R que permite realizar operações sobre os dados contidos nas várias estruturas disponíveis (vetor, data frame, listas). digite no prompt R o seguinte comando

 ??base::apply 

e você verá o conjunto de funções pertencentes a esta família,algumas delas não serão tratadas neste post.

A utilização destas funções permitem automatizar a aplicação das operações desejadas, permitindo assim ganhos de velocidade durante procedimentos que necessitam ser repetidos sobre todos os dados. No post de hoje vamos ver o funcionamento destas funções. Para iniciar vamos ver como funciona a função apply. O entendimento desta função permitirá a compreensão das demais.

Função Apply:

Considere a seguinte matriz 3×4 contendo números de 1 a 12 preenchidos por linha.


A <- matrix(1:12,nrow=3,byrow=TRUE)
 A #veja a matriz

Vamos supor que desejamos saber o valor total de cada linha desta matriz. Isto poderia ser feito manualmente da seguinte forma:

linha1<-sum(A[1,]) # soma os elementos da linha 1
 linha2<-sum(A[2,]) # soma os elementos da linha 2
 linha3<-sum(A[3,]) # soma os elementos da linha 3

Este processo é de longe a pior escolha. Para grandes conjuntos de dados ele se torna desgastante. No entanto podemos observar que há um padrão nos comandos utilizados, a função sum() é aplicada repetidamente sobre a matriz e somente o identificador da linha altera em cada procedimentos.

Podemos  desenvolver uma função que automatize este processo. Esta função deve receber a estrutura contendo os dados, o sentido de busca (linha ou coluna) e a função que deve ser aplicada. A simples função abaixo pode ser utilizada com uma matriz ou data frame. O argumento “sentido” deve receber os valores “linha” ou “Coluna” (entre aspas). O argumento “função” pode ser uma função base do R (mean, sum, sd, min, max,…) ou uma função definida pelo usuário.


minhafunçãoApply <- function(x,sentido,função){

#sentido: "linha" ou "coluna"
 resultado <- c()
 fc<-função
 if(sentido==){
 for (i in 1:nrow(x)){

resultado[i]<- fc(x[i,])

}
 }

else{
 for (i in 1:ncol(x)){
 resultado[i] <- fc(x[,i])
 }
 }

return(resultado)
 }

minhafunçãoApply(A,sentido="linha",sum)

[1] 10 26

No exemplo acima a função base sum() foi aplicada a cada linha da matriz A e o resultado foi retornado (10,26,42). O mesmo resultado pode ser obtido com a função apply.
A função Apply, presente no pacote base, necessita de 3 argumentos para seu funcionamento: a matriz ou data frame contendo os dados, a indicação do sentido de aplicação da função, representado pelos números 1 (linha) ou 2 (coluna) e a função a ser aplicada

> apply(A,1,sum)

[1] 10 26 42

Podemos também adicionar nossa pŕopria função:


#Função para adicionar 10 ao total da linha ou coluna

funcao_usuario <- function(x){

return(sum(x)+10)

}

minhafuncao( A,sentido="linha",funcao_usuario) ou

[1] 20 36 52

apply(A, 1, funcao_usuario)

[1] 20 36 52

Funções lapply e sapply

As funções lapply e sapply são uma variação utilizada para aplicar um procedimento aos elementos de uma lista. Esta funções diferem somente na forma como os resultados são mostrados. Para a função lapply o resultado esta na forma de lista, enquanto na sapply o resultado é apresentado na forma de vetor.


set.seed(5)
#Cria uma lista contendo os vetores "consumo", "peso" e um data frame "data" contendo duas colunas (a e b) com 10 linhas
minhalista <- list( consumo=c(1.25, 1.54,1.45) , peso = c(45,50,53),data=data.frame(a=rep(1:5,each=2),b=rnorm(10)))

#Soma todos cada um dos elementos da lista e retorna uma lista com os valores
lapply(minhalista,sum)
$consumo
[1] 4.24

$peso
[1] 148

$data
[1] 29.21148
#Soma todos cada um dos elementos da lista e retorna um vetor com os valores
> sapply(minhalista,sum)
consumo peso data
4.24000 148.00000 29.21148

#Soma somente as colunas do elemento data(um dataframe) retorna uma lista com os valores
> lapply(minhalista$data,sum)
$a
[1] 30

$b
[1] -0.7885155

Também é possível utilizar função definida pelo usuário


lapply(minhalista$data,funcao_usuario) # adiciona 10 a cada elemendo do dataframe de nome data contido na lista e soma cada coluna deste dataframe

Tapply

A função tapply é utilizada para aplicar um procedimento a diferentes partes dos dados dentro de um array, matriz ou data frame. Ela difere das demais funções vista até aqui por exigir a existencia de uma variável categórica o qual servirá para agrupar os dados aos diferentes níveis. Ela é muito útil quando queremos saber, por exemplo, a média de cada um dos tratamentos avaliados em um experimento.

A função tapply utiliza 3 argumentos: (1)A estrutura contendo os dados (vetor,matriz,data frame, array) onde será aplicada a operação; (2) Um vetor de variáveis categóricas que determina a estrutura dos dados; (3) a função que desejamos aplicar.


consumo <- c(13.10,15.20,16.10,14.75,15.35,16.20) #cria o vetor de resposta
grupo<-as.factor(c("15%PB","18%PB","18%PB","15%PB","15%PB","18%PB"))#cria vetor de fatores indicando o grupo experimental
#Obtêm a média de consumo em função do concentração de PB da dieta
tapply(consumo,grupo,mean)

mapply

A função mapply é uma versão multivariada da função lapply e sapply. As funções lapply e sapply atuam somente sobre os elementos de uma única lista. No caso da função mapply a função é aplicada sobre o primeiro elemento de cada um dos argumentos, em seguida ao segundo elemento, seguindo ao terceiro, e assim por diante. Os argumentos podem ser listas ou vetores. Vamos ver um simples exemplo para ilustrar seu funcionamento


a<-c(1,2,3,4)
b<-c(5,6,7,8)
mapply(sum, a,b) #soma os elementos dos vetores a e b

O que fizemos ao utilizar esta função foi:


(a[1]+b[1]);(a[2]+b[2]);(a[3]+b[3]);(a[4]+b[4])

Vejamos outro exemplo utilizando uma lista:


L1 <- list(a = LETTERS[c(4,6,12,6)], b = LETTERS[c(1,5,21,1)])
L2 <- list(c = LETTERS[c(4,14,22,20)], d = LETTERS[c(15,15,1,15)])
#duas listas L1 e L2 contendo os elementos a,b e c,d respectivamente contendo letras do alfabeto
#visualize as listas
L1
L2
# une as letras, contidas na mesma posição de cada vetor da lista L1 e L2 para escrever as palavras DADO, FENO,LUVA e FATO
mapply(paste, l1$a, l1$b, l2$c, l2$d)

Publicado em Dicas R | Marcado com , , , | Deixe um comentário

Como transferir seus pacotes R instalados durante a formatação

tranferindo imagensRecentemente, resolvi formatar meu computador. Fiz backup dos arquivos comuns (documentos de texto, videos, musicas). Também salvei a lista de favoritos do firefox e senhas memorizadas, pois queria após a formatação colocar todas as coisas no lugar. Salvar meus R scripts foi fácil já que mantenho uma pasta exclusiva para salvar arquivos “.R” “.RData”, etc. No entanto a dúvida surgiu quando pensei em uma forma de listar os pacotes que tenho instalados e automaticamente reinstalá-los após a formatação. Com buscas na internet e principalmente com a ajuda dos membros da comunidade brasileria do R R-br (clique no link para ver a discussão), consegui atingir meus objetivos e decidir compartilhar aqui no blog .

Eu possuía um sistema dual boot (windows7/Ubuntu 14.04) o qual formatei para Debian Jessie. Os comandos abaixo foram assim utilizados para Ubuntu e Debian.

Dicas iniciais

Se você irá fazer uma formatação semelhante, recomendo criar durante a formatação uma partição no hd para instalar o novo sistema e outra partição para a pasta “home”. Desta forma caso haja a necessidade de uma nova formatação,você necessitará formatar somente a partição onde encontra-se o sistema. Então vamos aos comandos.

Passo 1: Fazer o backup dos pacotes intalados (ANTES DA FORMATAÇÃO)

Faça as devidas alterações conforme seu sistema ( altere o caminhopara o diretório onde será salvo o arquivo .rda)

Substitua file=”insira caminho para o diretorio onde será salvo o arquivo)

tmp = installed.packages() 
installedpackages = as.vector(tmp[is.na(tmp[,"Priority"]), 1]) 
save(installedpackages, file="/media/fernando/SINERGIA/Backup Ubuntu/installed_packages.rda") 

Uma vez salvo o arquivo “installed_packages.rda”, você pode formatar seu computador (Se todos os demais documentos ja tiverem sido salvos, claro!).

Após  a formatação instale o software R utilizando o terminal (Debian e Distros baseadas).

sudo apt-get install r-base

Usuários windows instale utilizando os assistentes de instalação fornecidos pelo programa.

Passo 2: Criar uma biblioteca pessoal

Antes de restaurar os pacotes R utilizados é interessante criar uma biblioteca particular onde possamos guardar os arquivos dos pacotes que viermos a instalar, separando desta forma da biblioteca padrão do R, onde ficará instalados somente os pacotes básicos do R.  Este procedimento é vantajoso pois, caso você necessite remover a versão do software R instalada no futuro ( formatação, atualização. etc) você não precisará criar esta lista novamente. Vou deixar aqui o link do Fernando Mayer, para uma maior discussão sobre o assunto. Os passos para esta criação são os seguintes:

Crie um diretório na pasta Home (usuário linux)

#diretorio da nova biblioteca (usuários linux somente)
mkdir /home/nomeusuario/R/library 

Crie um arquivo utilizando um editor de texto (kwrite, bloco de notas, Gedit, etc) e salve no diretório home com o nome “.Renviron” (com um ponto antes do nome, este arquivo ficará invisível na pasta home). Insira neste documento a seguinte linha e salve o documento.

R_LIBS=/home/nomeusuario/R/library

Abra o R e digite o seguinte comando para verificar a inclusão do novo diretório. O diretório padrão do R e o novo diretório devem aparecer como resultado, indicando que seu sistema está pronto para receber novos pacotes.


.libPaths()

Saída

"/home/nomeusuario/R/library" "/usr/local/lib64/R/library"

Passo 3: Restaure os pacotes R

Para restaurar os pacotes no R  digite a área de trabalho do R o seguinte comando, substituindo na função “load” o endereço do diretório onde você salvou o arquivo “installed_packages.rda”, antes da formatação.

load("/media/<span class="bold highlight search-highlight">fernando</span>/SINERGIA/Backup
Ubuntu/installed_packages.rda")

for (count in 1:length(installedpackages))
install.packages(installedpackages[count])

Usuários Windows (Não testado!)

Como não possuo mais o sistema Windows, não fui capaz de testar o comando abaixo. O comando  pode ser utilizado por usuários de qualquer sistema uma vez que utiliza funções do R somente (Postem aqui se funcionarem para vocês)

Crie  um diretório na pasta  meus documentos

Na área de trabalho do R insira os seguintes comandos, com as devidas alterações (caminho para o diretório criado).


.libPaths( c( .libPaths(), "C:/Usuario/eu/Documentos/minha_R_biblioteca"))

.libPaths()

Após este comando, você deverá ver o caminho para o diretório padrão do R e para o novo diretório criado. A partir de então todos os pacotes baixados será instalado no novo diretório.

Após esta etapa restaure os pacotes da velha instalação conforme passo 3.

Até a próxima!

Publicado em Dicas R | Marcado com , , , | Deixe um comentário