Arquivo

Archive for the ‘linux’ Category

Emacs personalizado

Printscreen da minha sessão Emacs com as atuais configurações do arquivo .emacs.

Trocando umas idéias com o Fernando Toledo (co-autor do Ridículas) aprendi diversas opções disponíveis para personalizar o Emacs, meu editor de scripts R. A personalização torna a experiência mais agradável, de forma que o usuário pode habilitar ferramentas do editor que proporcionem mais conforto e agilidade. Algumas opções de personalização são os padrões de cores. Eu por exemplo prefiro um fundo preto pois acredito que cansa menos. Numeração na margem é outro aspecto interessante, principalmente para situar pessoas que acompanham algum curso com o R usando o Emacs. O realçador de parenteses é outro recurso que evita perda de tempo na depuração de um código. E coisas como especificar o tamanho de letra e definir como padrão os comandos ctrl-zxcv para desfazer-recortar-copiar-colar evitam de você ter que fazer isso graficamente em toda sessão. Para usar o esquema de cores você vai ter que instalar o emacs-goodies-el

$ sudo apt-get install emacs-goodies-el

Uma vez instalado, o restante das opções você consegue copiando para o seu arquivo .emacs, que fica na sua home (se não existe, crie um), os trechos desejados do meu atual arquivo .emacs

;;;--------------------------------------------------------------------------
;;; arquivo de configuração do Emacs por Walmes Zeviani

;;---------------------------------------------------------------------------
;; faz com que o emacs23 fique no modo de texto visual
;; (quebra de linha visual) quando edita porção tex de um Rnw
(add-hook 'text-mode-hook 'turn-on-visual-line-mode)

;;---------------------------------------------------------------------------
;; faz com que apareceça os argumentos das funções do R no minibuffer
(require 'ess-eldoc)

;;---------------------------------------------------------------------------
;; numeração das linhas na margem esquerda
(global-linum-mode 1)

;;---------------------------------------------------------------------------
;; auxilia na identação do código, colunas coloridas após certa distância
(require 'whitespace)
(setq whitespace-line-column 77)
(setq whitespace-style '(face tabs lines-tail trailing))
(global-whitespace-mode t)

;;---------------------------------------------------------------------------
;; inicia Emacs com ctrl-{zxcv} abilitado para desf/recor/cop/colar
(cua-mode t)

;;---------------------------------------------------------------------------
;; realçador de pareamento de parenteses, chaves, colchetes, aspas...
(show-paren-mode 1)

;;---------------------------------------------------------------------------
;; tamanho da fonte (120~12pt)
;; comandos C-x C-+ e C-x C-- para aumentar e diminiur o tamanho da fonte
(set-face-attribute 'default nil :height 120)

;;---------------------------------------------------------------------------
;; estilo de cores de fundo e fontes, mais disponíveis em
;; http://themes.sweyla.com/
;; http://jasonm23.github.com/emacs-theme-editor/

(defun sweyla838549 ()
  "Theme generated by Sweyla: http://themes.sweyla.com/seed/838549/"
  (interactive)
  (color-theme-install
   '(sweyla838549
     ((background-color . "#010000")
      (foreground-color . "#FFFFFF")
      (background-mode . dark)
      (border-color . "#323232")
      (cursor-color . "#FFFFFF")
      (mouse-color . "#323232"))
     (mode-line ((t (:foreground "#FFFFFF" :background "#323232"))))
     (region ((t (:background "#323232"))))

     (font-lock-comment-face ((t (:foreground "#00FF73"))))
     (font-lock-constant-face ((t (:foreground "#58D3A8"))))
     (font-lock-builtin-face ((t (:foreground "#16AF3D"))))
     (font-lock-function-name-face ((t (:foreground "#82FFD5"))))
     (font-lock-variable-name-face ((t (:foreground "#00FFD2"))))
     (font-lock-keyword-face ((t (:foreground "#3AFFC4"))))
     (font-lock-string-face ((t (:foreground "#04F069"))))
     (font-lock-doc-string-face ((t (:foreground "#04F069"))))
     (font-lock-type-face ((t (:foreground "#00FFFF"))))
     )))

(provide 'sweyla838549)

(require 'color-theme)
(color-theme-initialize)
(sweyla838549)

;;---------------------------------------------------------------------------

Visite os dois links disponíveis na parte de cores. Nesses sites você pode definir um esquema de cores próprios para sua sessão Emacs. Daí é só aproveitar a boa experiência que o Emacs dá à edição de código R e LaTex. A figura no início do post é um printscreen do meu Emacs com essas configurações. Atualmente eu uso o Emacs23 no Ubuntu 12.04. Não esqueça para usar o R com Emacs você precisa instalar o ess

$ sudo apt-get install emacs23 ess

Meus agradecimentos ao Fernando Toledo pelas preciosas dicas. Até a próxima ridícula.

Anúncios
Categorias:linux Tags:

Paralelização de Processos II

Dando continuidade ao que foi apresentado no post sobre paralelização de processos e motivado pelo comentário do colega J. Franky e fundamentalmente com a ajuda de Benilton Carvalho (aos quais deixo meu agradecimento), nesse “fast-post” vou mostrar uma outra implementação em paralelo.

O cenário é exatamente o mesmo do apresentado no post anterior (veja para entender). Agora, entretanto o processamento paralelo se dará em dois “níveis”, a saber: As nsmc simulações correm como um fork, ou seja, cópias do mesmo processo. Elas são implementadas como uma função e “correm” com a função mclapply(), o argumento mc.set.seed = TRUE garante que cada uma das nsmc terá uma semente geradora de números diferente.

Dentro de cada simualação temos ainda dois processos independentes dentro de cada ciclo (as duas estratégias de amostragem). Para um caso em que cada uma dessas estratégias demore um tempo grande, ao invés de esperar que a primeira termine para então começar a segunda, usamos uma versão de thread, com as funções parallel() e collect() e paralelizamos as duas estratégias.

O argumento mc.set.seed = TRUE tem o mesmo propósito que anteriormente, o argmento name = ‘foo’ é um grande facilitador… Vocês vão entender! Ao passar uma tarefa (a estratégia de amostragem) pela função parallel() é mesmo que dar um comando no terminal com um ‘nohup &’, ou seja, o computador executa a tarefa mas não “bloqueia” tal terminal para outro comando.

Depois de paralelizados, os processos são coletados pela função collect() na estrutura de uma lista, temos como argumentos da função (que não estão sendo usados, veja a documentação) o wait, ele é muito útil quando queremos que se espera ‘X’ tempo pelo fim das tarefas, após esse tempo, o processo continua.

A vantagem do uso do argumento name = ‘foo’ é que por default os nomes na estrutura da lista do collect recebem o número PID do processo, ao atribuir um nome fica muito mais fácil distribuir o que foi paralelizado.

Espero que tenham gostado… Lembrando que este é um exemplo puramente didático, que provavelmente não se aplica ao uso desses procedimentos. Segue portando código da terceira implementação, agora com o uso de paralelização em dois níveis.

#-----------------------------------------------------------------------------
## PARAMETROS DA SIMULAÇÃO -- usar os mesmo para as duas situações
n <- 5000 # numero de individuos
ciclos <- 30 # numero de ciclos
nsmc <- 100 # numero de simulacoes

## SEGUNDO CASO -- paralelizada
#-----------------------------------------------------------------------------
## IDEM (realiza um simulacao de 'nsmc')
simula.ii <- function(x) { # inicio da funcao -- sem argumentos
  ## mesmos comentarios do caso acima
  resultados <- matrix(NA, ciclos, 4) 
  p0 <- sample(c(0, 1, 2), n, replace = TRUE, prob = c(.25, .5, .25))
  resultados[1, ] <- rep(c(mean(p0), var(p0)), times = 2)
  estrA <- sample(p0, n/5, replace = FALSE)
  estrB <- p0[seq(1, 5000, 5)]
  resultados[2, ] <- c(mean(estrA), var(estrA), mean(estrB), var(estrB))
  for(k in 3:ciclos) {
    ## pA e pB paralelizados em 'thread'
    pA <- parallel(tipoA(estrA), name = 'A', mc.set.seed = TRUE)
    pB <- parallel(tipoB(estrB), name = 'B', mc.set.seed = TRUE)
    estrG <- collect(list(pA, pB)) # coleta dos processos paralelizados
    estrA <- estrG$A; estrB <- estrG$B # redistribui os processos
    resultados[k, ] <- c(mean(estrA), var(estrA), mean(estrB), var(estrB))
  }
  return(resultados) # retorna uma simulacao
}

tempoC <- system.time({ # armazena o tempo de processamento
saida3 <- mclapply(1:nsmc, # numero de nsmc
# aplica a funcao -- faz a simulacao
                   simula.ii,
                   mc.preschedule = FALSE,
                   # 'expande' quantos processos forem possiveis
                   mc.set.seed = TRUE,
                   # uma semente para cada processo
                   mc.cores = getOption('cores'))
                   # usa quantos processadores forem possiveis
})

## TEMPO
tempoC[3]

Até a próxima!

Usando o R para fazer downloads de arquivos

Printscreen do diretório com destaque para a seleção dos detalhes do arquivo. O conteúdo selecionado é importado para o R.

Neste link (ce223-2011-01) estão os scripts das minhas aulas de Estatística Computacional, ministradas no primeiro semestre de 2011 para o curso de Estatística da UFPR. Esse curso abordou diversos tópicos, incluindo expressões regulares, manipulação de datas, gráficos da lattice, etc. Aos interessados, é possível fazer o download arquivo por arquivo ou usar o R para automatizar tal tarefa. Isso eu vou ensinar nesse post: como fazer download de arquivos com o R (no linux).

Abra uma sessão R. Agora abra o link dos arquivos no seu navageador. Com o mouse faça a seleção das linhas contendo o nome dos arquivos. Copie para área de transferência (ctrol+c). No R você vai carregar o conteúdo copiado e armazenar em um data.frame. Isso é porque precisamos do nome dos arquivos. Juntando o nome dos arquivos ao prefixo do link, podemos fazer download usando o comando wget do linux. Faremos o R submeter todos os links para o linux baixar. Veja o CMR abaixo. Até a próxima ridícula.

#-----------------------------------------------------------------------------
# diretório web onde estão os arquivos
dire <- "http://www.leg.ufpr.br/~walmes/ensino/ce223-2011-01/"
browseURL(URLencode(dire)) # abra a página no seu navegador

#-----------------------------------------------------------------------------
# lendo a tabela com nome dos arquivos (via ctrol+c)
tab <- read.table("clipboard", header=FALSE, sep="\t", stringsAsFactors=FALSE)
str(tab)

#-----------------------------------------------------------------------------
# segunda coluna corresponde ao nome dos arquivos
arq <- tab$V2

#-----------------------------------------------------------------------------
# suponha que eu queira apenas os arquivos de extensão *.R, eles são
extR <- grep(".R$", arq, value=TRUE)

#-----------------------------------------------------------------------------
# formar o nome dos links para download, colocar o wget antes pois é o comando
links <- paste("wget ", dire, extR, sep="")
links[1]

#-----------------------------------------------------------------------------
# usar a função system() para fazer download com wget

sapply(links, system)

#-----------------------------------------------------------------------------
# pronto, todos os downloads foram feitos. Agora você pode ir na página desses
# caras sabidões e ter as notas de aulas, arquivos, seminários para poder
# aprender. Visite essas páginas:
# http://www.commanster.eu/
# http://socserv.mcmaster.ca/jfox/
# http://www.stat.wisc.edu/~bates/
# http://www.stat.missouri.edu/~ferreiram/
# http://www.isid.ac.in/~deepayan/
# http://www.math.mcmaster.ca/~bolker/
#-----------------------------------------------------------------------------
Categorias:linux Tags:, ,

Paralelização de processos

Hoje em dia os computadores estão cada vez mais rápidos e via de regra, nossos processsadores tem mais de um núcleo de processamento. Isso é um “horizonte” grande que nos permite avançar num campo “baixo nível” da informática de gerenciar nossos processos para que eles sejam feitos em paralelo entre os vários núcleos do processador. Esse procedimento tem recomendações bem específicas e portanto não tem reflexos gerais em qualquer aplicação.

Estou tentando aprender sobre isso e ultimamente andei lendo e brincando com esses procedimentos que estão disponíveis no R. Basicamente existem três tipos de paralilazação. As de baixo nível, que envolvem um profundo conhecimento do hardware e assim como li, não são tão recomendadas para usuários finais. Outras são as paralizações explícitas em que o usuário é quem “manda” e por fim, já está disponível no R (exceto plataforma Windows) pacotes em que é possível implementar o processo de paralelização implícita, em que o usuário interage com ferramentas internas de “baixo nível” e o computador faz o resto… (brincadeira).

No primeiro tipo, se esse for seu propósito veja a documentação dos pacotes multicore (funções fork() e children()). No segundo caso procure sobre o pacote snow. E no último caso, ao qual vou dar mais atenção, veja sobre os pacotes doMC e multiocore especificamente nas funções mclapply(), parallel() e collect().

Como exemplo vou apresentar um caso bem tosco por sinal, mas acho que bastante ilustrativo. A primeira parte do código é uma implementação bem naive de uma simulação em que sobre uma população são retiradas dois tipos de amostra, para esses dois casos são em sequencia em um certo número de ciclos retiradas amostras. Esse processo por sua vez é repetido nsmc vezes (abreviatura de numero de simulações de Monte Carlo). Para as duas implementações (a naive e a paralela) é armazenado o tempo de processamento. Veja a diferença… Se você quiser ver a coisa acontecendo, abra o capô do seu computador, no terminal digite top, vai abrir o gerenciador de processos, e você vai conseguir ver no caso da implementação em paralelo, as várias cópias do seu processo correndo, diferentemente da implementação naive em que cada simulação só começa quando a anterios acaba.

Segue o código

#-----------------------------------------------------------------------------
## PARAMETROS DA SIMULAÇÃO -- usar os mesmo para as duas situações
n <- 5000 # numero de individuos
ciclos <- 30 # numero de ciclos
nsmc <- 100 # numero de simulacoes

## PRIMEIRO CASO -- "naive"
#-----------------------------------------------------------------------------
saida1 <- vector('list', length = nsmc) # saida da implementacao SIMPLES
tempoA <- system.time({ # armazena o tempo de processamento
   for(i in 1:nsmc) { # laço -- para cada simulacao
   resultados <- matrix(NA, ciclos, 4) # matriz dos resultados individuais
   # populacao inicial
   p0 <- sample(c(0, 1, 2), n, replace = TRUE, prob = c(.25, .5, .25))
   resultados[1, ] <- rep(c(mean(p0), var(p0)), times = 2) # resultado ciclo 0
   estrA <- sample(p0, n/5, replace = FALSE) # estrategia A
   estrB <- p0[seq(1, n, 5)] # estrategia B
   # resultados ciclo 1
   resultados[2, ] <- c(mean(estrA), var(estrA), mean(estrB), var(estrB))
   for(k in 3:ciclos) { # laço -- ciclos subsequentes
      ## populacao estrategia A ciclo n
      pA <- sample(estrA, n, replace = TRUE)
      estrA <- sample(p0, n/5, replace = FALSE)
      ## populacao estrategia B ciclo n
      pB <- sample(estrB, n, replace = TRUE)
      estrB <- pB[seq(1, n, 5)]
      # resultados ciclo n
      resultados[k, ] <- c(mean(estrA), var(estrA), mean(estrB), var(estrB))
   }
   saida1[[i]] <- resultados # armazena na saida
}
})

## SEGUNDO CASO -- paralelizada
#-----------------------------------------------------------------------------
## IDEM (realiza um simulacao de 'nsmc')
simula.i <- function(x) { # inicio da funcao -- sem argumentos
   ## mesmos comentarios do caso acima
   resultados <- matrix(NA, ciclos, 4)
   p0 <- sample(c(0, 1, 2), n, replace = TRUE, prob = c(.25, .5, .25))
   resultados[1, ] <- rep(c(mean(p0), var(p0)), times = 2)
   estrA <- sample(p0, n/5, replace = FALSE)
   estrB <- p0[seq(1, n, 5)]
   resultados[2, ] <- c(mean(estrA), var(estrA), mean(estrB), var(estrB))
   for(k in 3:ciclos) {
      pA <- sample(estrA, n, replace = TRUE)
      estrA <- sample(p0, n/5, replace = FALSE)
      pB <- sample(estrB, n, replace = TRUE)
      estrB <- pB[seq(1, n, 5)]
      resultados[k, ] <- c(mean(estrA), var(estrA), mean(estrB), var(estrB))
   }
   return(resultados) # retorna uma simulacao
}

tempoB <- system.time({ # armazena o tempo de processamento
saida2 <- mclapply(1:nsmc, # numero de nsmc
# aplica a funcao -- faz a simulacao
                   simula.i,
                   mc.preschedule = FALSE,
                   # 'expande' quantos processos forem possiveis
                   mc.set.seed = TRUE,
                   # uma semente para cada processo
                   mc.cores = getOption('cores'))
                   # usa quantos processadores forem possiveis
})

## TEMPOS
tempoA[3]
tempoB[3]

Vale lembrar que é preciso estar usando ou Linux, ou Mac e é preciso antes fazer o download e chamar o pacote “multicore”. Espero que tenham gostado e que com esse exemplo consigam realizar suas próprias paraleilazações.

Categorias:linux, notícias, testes

Instalar pacotes não oficiais do R via terminal (linux)

Boa tarde senhores! Hoje estou aqui para lhes dar uma dica de como instalar pacotes não oficiais e até mesmo oficiais do R. Afinal de contas, quem nunca se deparou com esta dúvida. No windows é fácil, basta fazer o download do pacote, extraí-lo e colocá-lo dentro da pasta library do R. E quem usa linux, como proceder? É extramente simples. O procedimento pode ser encontrado no site oficial do R, mas para que você não perca tempo procurando onde está esta dica no site do R, eu irei colocar  aqui como se faz isso. Neste caso, estou utilizando o linux Mint 10. Primeiro faça o download do pacote em formato “tar.gz”. Suponhamos que estamos interessados em instalar o pacote não oficial “ExpDes”.  Entre no site onde está o pacote e baixe-o (Observação: Acredito que a versão em português deste pacote esteja com problemas, pois só consegui instalar a versão em inglês). Abra o terminal e mude o diretório para pasta onde está o arquivo. Tente fazer direto também, sem mudar o diretório. Caso dê erro, faça da maneira que estou explicando. Mudando o diretório para pasta onde está o arquivo.

ivan-Aspire-5920 ~ $ cd /home/ivan/Downloads

Verificando se o arquivo está na pasta.


ivan-Aspire-5920 ~ /Downloads$ ls

ExpDes_1.0.tar.gz

Entre como usuário “root”.

ivan-Aspire-5920 ~ /Downloads$ sudo su

[sudo] password for ivan:

Agora é só instalar digitando a seguinte linha de comando:


ivan-Aspire-5920 Downloads # R CMD INSTALL ExpDes_1.0.tar.gz

Pronto senhores, está instalado o pacote. Até a próxima dica. Abraços!

Categorias:linux

Dicas de como usar o Emacs com o R

O R possui diversos editores (Rkward, JGR, Tinn-R, RStudio, entre outros). O emacs é o meu editor preferido, talvez porque foi com o qual eu comecei a usar o R no Linux. Esse editor possui várias vantagens e nesse post eu vou ressaltar algumas delas.

Para instalar o emacs no linux, você deve ir para o terminal e pedir

$ sudo apt-get install emacs23 ess

O ess é uma componente que deve ser instalada junto com o emacs para que reconheça a linguagem R, aplicando então os realces (highlights) e a indentação do código. Os realces são cores aplicadas ao código que identificam as strings, as funções, os comentários, ajudam a controlar os pares de parênteses/colchetes/chaves, permitindo a rápida identificação de estruturas de hierarquia de funções. A indentação garante um aspecto mais organizado para o código, principalmente para pessoas que fazem funções e desenvolvem pacotes. Um código com indentação fica mais fácil de ser lido por terceiros e permite facilmente a identificação de erros de programação.

Algumas curiosidades sobre o emacs+ess são os atalhos para o sinal de atribuição <- que é obtido com um simples underline. Outra utilidade é a repetição de caracteres que eu uso para traçar linhas horizontais no meu código, separando passos da minha análise. Segure (segura ctrl)+(número de repetições)+(solta ctrl)+(caracter a repetir). Para fazer uma linha comentada com 50 traços é só fazer (segura ctrl)+(50)+(solta ctrl)+(-). O leitor pode perceber que meus códigos R sempre possui esses traços horizontais. Detalhe: aprendi fazer isso acidentalmente.

No emacs existem comandos específicos para recortar/copiar/colar texto. Para ativar os usuais ctrl+x/c/v, você deve ir no menu options e habilitar a opção C-x/C-c/C-v Cut and Paste (CUA).

O emacs possui atalhos para avaliar o código R. Os atalhos mais usuais são:

  • ctrl+c+j — avalia uma linha de código e não muda o cursor para a linha seguinte;
  • ctrl+c+n — avalia uma linha de código e  muda o cursor para a linha seguinte;
  • ctrl+c+p — avalia um parágrafo (região sem quebra de linha no código);
  • ctrl+c+r — avalia uma região selecionada do código;
  • ctrl+c+f — avalia uma função, ignora as quebras de linha.

Ao usar o R no emacs, por padrão a janela é dividida verticalmente. O script fica na porção superior e o console na porção inferior. Para mexer a barra de rolagem do script usa-se as teclas page up e page down. O interessante é que com alt+page up e alt+page down pode-se mexer a barra de rolagem do console sem mudar o cursor para o console. Isso é útil quando queremos rever algum resultado que já ficou escondido no console.

No emacs, ao aplicar uma função do R, é possível previamente saber os argumentos que essa função recebe. Isso e mostrado no buffer inferior (uma linha de buffer). Para isso é necessário que exista um arquivo .emacs na sua home do linux (/home/user) com a seguinte linha

(require 'ess-eldoc)

No linux, todo arquivo/diretório que começa com ponto é oculto. Você pode localiza-lo de forma gráfica no menu ver > mostrar arquivos ocultos, para então abrir com gedit e adicionar a linha. Pode-se fazer isso por terminal, indo para a sua home, listando os arquivos ocultos e abrindo o desejado com o vi. Se o arquivo não existir, você pode criá-lo com o conteúdo desejado usando o comando echo.

$ cd ~                                 # vai para o diretório home do usuário
$ pwd                                  # mostra o diretório para conferir
$ find .emacs                          # encontra o arquivo se ele existir
$ vi .emacs                            # abre o arquivo para edição
$ echo "(require 'ess-eldoc)" > .emacs # cria o arquivo se ele não existir

Feito isso, toda vez que abrir o primeiro parentese da função, vai aparecer os seus argumentos. Por exemplo, para função install.packages() aparece assim

install.packages(
install.packages: pkgs, lib, repos = getOption("repos"), contriburl = contrib.url(repos,
    type), method, available = NULL, destdir = NULL, dependencies = NA,
    type = getOption("pkgType"), configure.args = getOption("configure.args"),
    configure.vars = getOption("configure.vars"), clean = FALSE,
    Ncpus = getOption("Ncpus"), libs_only = FALSE, INSTALL_opts,
    ...

Esse tipo de informação você pode obter com a função args()

args(install.packages)

Para finalizar, o emacs possui três tipos de comentários. Ao usar uma tralha # (hash) e dar enter com o cursor na frente da tralha, o comentário é colocado no centro horizontal do script. Com duas tralhas, os comentários serão alinhados à esquerda no mesmo nível de profundidade do código. Com três tralhas, o comentário sempre vai ficar colado à esquerda. Veja abaixo o exemplo.

                                        # gráfico da lattice
require(lattice)
da <- expand.grid(x=1:20, z=gl(2,1,labels="A"))
da$y <- 0.3*da$x+as.numeric(da$z)+rnorm(da$x)
xyplot(y~x, data=da,
       ## identifica linhas separadas por grupos
       groups=z,
       ## controla cores, tipo de linha
       type="b", col=1:2, lty=1:2, pch=19,
       ## controla a legenda
       key=list(
         ## texto
         text=list(c("A1","A2")),
         ## opções de linha
         lines=list(lty=1:2, col=1:2)
         )
       )
### tentem fazer isso em casa crianças!

Para usuários de windows aconselho baixar o emacs da página do Vincent Goulet.

Categorias:linux Tags:, , , ,

Dicas para compilar Sweave no Linux

Sweave é o ponto de encontro entre o R e LaTeX. É uma ferramenta de edição de texto que combina o poder e elegância do LaTeX para edição de textos científicos com o as funcionalidades do aplicativo (mais que) estatístico R. Nesse post vamos apresentar dicas para compilar arquivos de extensão *.Rnw no terminal do Linux.

Considere que existe um arquivo mysweave.Rnw em um diretório de trabalho do seu Linux. Crie um arquivo de extensão *.sh que basicamente é um arquivo com comandos que são aplicados na linha do terminal do Linux. Use o nome swv.sh (acrônimo de sweave) e cole nele o conteúdo abaixo.

#!/bin/sh
# compila o arquivo *.Rnw gerando um *.tex
echo "library(tools); Sweave(paste(\"$1\",'.Rnw', sep=''))" | R --no-save --no-restore;
# compila o arquivo *.tex gerando um arquivo *.dvi
latex $1.tex
# compila o arquivo *.bib que contém as bibliografias
bibtex $1
# compila o arquivo *.tex gerando um arquivo *.pdf
pdflatex $1.tex

Cada comando do arquivo swv.sh contém um comentário acima da respectiva ordem que identifica a ação. O arquivo swv.sh deve estar no mesmo diretório do arquivo mysweave.Rnw e será onde os demais arquivos serão criados.

Nesse passo criaremos uma alias para o arquivo swv.sh. Para isso, vá no seu diretório pessoal (home) e edite o arquivo .bashrc (é um arquivo oculto). Adicione nesse arquivo as linhas abaixo.

# atalho para compilar *.Rnw
alias swv="./swv.sh"

Para compilar o seu arquivo mysweave.Rnw basta executar o comando swv no seu diretório de trabalho dessa forma

$ swv mysweave

Não é necessária a inclusão da extensão *.Rnw. É esperado que os respectivos arquivos mysweave.dvi e mysweave.pdf sejam gerados.

É possível definir esse atalho globalmente. Para isso, cole o arquivo swv.sh no diretório /bin. Para usar, na linha de comando faça

$ swv.sh mysweave

Dessa forma não é necessário ter o arquivo swv.sh em todo diretório com arquivos *.Rnw.

Categorias:linux, sweave Tags:, , , , ,