With this in .Rprofile (first line copied from ?Startup examples):
.First <- function() cat("\n Welcome to R!\n\n")
foo <- "bar"
I do not see the Welcome text. The following shows that .Rprofile executes.
ls()
[1] "foo"
Apparently .First() does not execute. Any idea why not?
I'm running in an Rgui console on win7pro with R v3.6.1 x64.
I already learned that I will not be able to do what I wanted to do in .First(), but I still want to know why it is not even executing. I might want to use it for something in the future. I haven't made any fancy configuration changes, and I launch the console from a shortcut to Rgui.exe.
Solved: Early on I had bad code in .First(). While troubleshooting I cleared the workspace with
rm(list=ls())
q('yes')
That way the assignment foo<-"bar" more clearly showed that .Rprofile was executing. What I didn't realize was that the bad .First() got saved in some hidden environment in .RData. After that, no matter what I did with .First() in .Rprofile, it always got replaced with the bad one. To solve the problem, I just needed to delete .RData.
Update: .First() does not go into a hidden environment, but the starting dot makes it hide from ls(). To exit with a completely clear workspace, the code would be:
rm( list=ls(all.names=T) )
q('yes')
That's a lot of typing. In the future, I think I'll just delete .RData.
To me this seems a lot like a bug. Anytime you change .First() in .Rprofile, you need to delete .RData from every folder where you use R or execute rm(.First) and `q('yes') in every folder. That just begs for something to be missed.
Related
Frequently, in RStudio, in a markdown file, I find myself doing command-shift-enter to run the current chunk. This pollutes the global R environment.
Is there anyway I can create a 'current environment' or 'live environment' so that anything that gets run in the console gets attached to that environment and not to the global one?
I think the answer is no, but I don't see this as a problem. You should be starting with a blank global environment every time (make sure you have "Save workspace to .RData on exit" to "Never" in the general global options).
It's a bad idea to rely on keeping variables in the global environment between sessions, because things gradually build up there, and you end up with non-reproducible results.
I want R to load a certain file on initialization, so naturally I added a source command to my Rprofile so:
.First <- function()
{
cat("\n Welcome to R MotherFnorder!!!\n\n")
setwd("/home/username/Code/R/")
source("/home/username/Code/R/file.R")
}
But now when I start R it throws a 'function not found' error for default functions like runif or rnorm. When I load the same file manually into the workspace I get no errors.
You don't need (or, really, want) to create a .First . If you put those lines into your .Rprofile they'll execute just fine. -- With the proviso #Pascal pointed out, that any function called in your file.R must have its library loaded first. So,
near the bottom of your .Rprofile, just put
library(whatever_packages_needed)
cat("\n Welcome to R MotherFnorder!!!\n\n")
setwd("/home/username/Code/R/")
source("/home/username/Code/R/file.R")
EDIT: I cannot reproduce your problem. I added these lines to the end of my .Rprofile:
#testing SO problem with libloading
library(stats)
runif(10)
And the console returns ten nice numbers.
The reason for the error is that when .First() the packages are not yet loaded.
Although runif and rnorm might seem like default functions, they are actually part of the stats package. And as such, they are NOT available when .First() is called (unless you specifically call that package from within .First)
... which also explains this:
When I load the same file manually into the workspace I get no errors.
After .First() but before you have the chance to run anything manually, the default packages are attached. And hence available to your functions when you call it manually.
The solution is to create a file (if it does not already exist) called
"~/.Rprofile" and put in there the lines you currently have in .First()
This is a terribly simple request, and I can't believe I haven't found the solution to this yet, but I've been searching for it far and wide without luck.
I have an .Rnw file loaded up in Emacs, I use M-n s to compile it.
Everything works well, and it even opens an R buffer. Great. But that buffer
is entirely useless: it doesn't contain the objects that I just sourced!
Example minimal .Rnw file:
\documentclass{article}
\begin{document}
<<>>=
foo <- "bar"
#
\end{document}
Using M-n s, I now have a new R-buffer with a session loaded up, but:
> foo
Error: object 'foo' not found
That is disappointing. I would like to play around with the data interactively.
How do I achieve that? I don't want to be sourcing the file line-by-line, or
region-by-region with C-c C-c or something similar every time I change my code.
Ideally, it should be just like RStudio's source function, that leaves me with
a fully prepared R session.
I haven't tried this with sweave yet, only with knitr.
EDIT: the eval=TRUE chunk option does not seem to result in the correct behaviour.
This behaviour was recently changed in ESS. Now sweave and knitr are executed directly in the global environment, as if when you write it yourself at command line. So wait for a couple of more weeks till ESSv13.09 is out or use the development version.
Alternatively, you can also set ess-swv-processing-command to "%s(%s)" and you will get the same result, except automatic library loading.
For the record, knitr (in contrast to sweave) evaluates everything in it's own environment unless you instruct it otherwise.
[edit: Something went wrong. I don't see the correct .ess_weave any more. Probably some git commit messup again. So it is not fixed in 13.09. Fixing it now. Sorry.]
Open an interactive R session, and then call Sweave directly, I believe like this (untested though). knitr works in the same way, though you need to load the knitr library first.
> Sweave("yourfile.Rnw")
There is some potential for peril here, though. If you call Sweave in a session after doing other things, your code can use things previously in the workspace, thus making your results unreproducible.
I'm trying to call a simple python script from within R using system2(). I've read some information I found vague that said if 'too much' memory is used, it won't work.
If I load a large dataset and use some information in it to use as arguments to pass into system2(), it will only work if I manually click "Restart R" in call Rstudio.
What I want:
df <- read.csv('some_large_file.csv')
###extracting some info called 'args_vec'
for(arg in args_vec){
system2('python', args)
}
This won't work as is. The for loop is simply passed over.
What I need:
df <- read.csv('some_large_file.csv')
###extracting some info called 'args_vec'
###something that 'restarts' R
for(arg in args_vec){
system2('python', args)
}
This answer doesn't quite get what I want. Namely, it doesn't work for me within Rstudio and it calls "system" (which presents the same problem as "system2" in this case). In fact, when I put the answer referenced above in my Rprofile.site file, it just immediately closed rstudio:
I tried the suggestion as a normal function (rather than using "makeActiveBinding", and it didn't quite work.
##restart R in r session -- doesn't work
makeActiveBinding("refresh", function() { system("R --save"); q("no") }, .GlobalEnv)
##nor did this:
refresh <- function() { system("R --save"); q("no") }
I tried a number of variations of these two options above, but this is getting long for what feels like a simple question. There's a lot I don't yet understand about the startup process and "makeActiveBinding" is a bit mysterious. Can anyone point me in the right direction?
In Rstudio, you can restart the R session by:
command/ctrl + shift + F10
You can also use:
.rs.restartR()
RStudio has this undocumented rs.restartR() which is supposed to do just that: restarting R.
However, it does not unload the packages that were loaded, nor does it clean the environment, so that I have some doubts about if it restarts R at all.
If you use RStudio, use the menu item Session > Restart R or the associated keyboard shortcut Ctrl+Shift+F10 (Windows and Linux) or Command+Shift+F10 (Mac OS). Additional keyboard shortcuts make it easy to restart development where you left off, i.e. to say “re-run all the code up to HERE”:
In an R script, use Ctrl+Alt+B (Windows and Linux) or Command+Option+B (Mac OS)
In R markdown, use Ctrl+Alt+P (Windows and Linux) or Command+Option+P (Mac OS)
If you run R from the shell, use Ctrl+D or q() to quit, then restart R.
Have you tried embedding the function call within the apply function, rather than a for loop?
I've had some pieces of code that ran the system out of memory in a for loop run perfectly with apply. It might help?
For those not limited to a command that want something that actually resets the system (no prior state, no loaded packages, no variables, etc.) you can select Terminate R from the Session menu.
It is a bit awkward (asks you if you are sure). If anyone knows something like clear all or really clear classes in MATLAB let me know!
Is there a way I can make an alias, within R, that will execute q() and then restart a clean R session?
And yes, I am too lazy to type q() and then the letter R :)
If you're in RStudio:
command/ctrl + shift + F10
You can also use
.rs.restartR()
Depending on how you start R try placing one of these lines into your .Rprofile file:
makeActiveBinding("refresh", function() { shell("Rgui"); q("no") }, .GlobalEnv)
makeActiveBinding("refresh", function() { system("R"); q("no") }, .GlobalEnv)
Then entering this into the R console:
refresh
will shut down the current session and start up a new one.
I found that .rs.restartR() works similar to pressing ctrl+shift+F10. but dose not unload the packages
As another alternative, Emacs ESS (>= 16.10) can reload the inferior R process via inferior-ess-r-reload-hook which is bound to C-c C-e C-r by default.
After looking for a solution to this, I solved my problem based on this solution here, using the R Package RDCOMClient.
The solution bellow just work within RStudio (Windows), once it simulates the keypresses ctrl+ shift + F10.
The RDCOMClient package must be installed with the command bellow:
install.packages("RDCOMClient", repos = "http://www.omegahat.net/R")
The code to simulate the keypresses within RStudio (Windows 10) are:
library(RDCOMClient)
wsh <- COMCreate("Wscript.Shell")
wsh$SendKeys("^+{F10}")
In the last line in the code above, the 'ctrl' key is represented by '^' and the shift key by '+'. All the explanations for this key representaions are available here.
Just after running the last line of the code above, the whole R session in RStudio will be reset, according to #steadyfish's comment. That is, it removes all the data from current session and unload all the loaded packages in the session.
Old post, but none of the answers quite work (for me, I'm using Windows, haven't tested others), so I'll add my solution. Some of my terminology might be off here, but this should get the point across:
Above answers don't quite work
Most of the answers submitted here involve using shell or system which doesn't quite work because while they open a new R console and do instruct the original console to close, the new console is a process running in the application context of the old console. That means the original console cannot close until the new console closes. Some of the users above such as hedgedandlevered reported that closing the original console forces the new console to close. When I try, the new console does open, but the old console remains open in a frozen state until the new console is closed.
The basic problem is calling shell or system does not change the application context from the original console to the new one, and therefore the original process cannot terminate until the new console closes.
Alternative that works for me
Instead use shell.exec which would normally be used to open a file in the default application based on file type. When used on a .exe, apparently, it runs the executable. The important difference, though, is that the system starts the application in it's own separate context. So here's the code that works for me:
makeActiveBinding("restart.R", function() { shell.exec(paste0(R.home(),"/bin/x64/Rgui.exe")); q("no") }, .GlobalEnv)
You'll need to edit the file path /bin/x64/Rgui.exe to match whatever you use to start R. You just put this line in your .Rprofile file, then you can call it by entering restart.R in your R code.
The downside of this over other methods is that you can't pass command line arguments like --no-save as you would with just shell, but at least this will let you close out the original R process.
Write this function in your .Rprofile
r <- function() {
assign('.Last', function() {system('R')}, envir = globalenv())
quit(save = 'no')
}
r() restarts you R session. Loaded packages will not reload. Your environment wont be saved.
Works for Linux. No idea of what may happen on other OS
In line with Martin Morgan's idea of using .Last(); this restarts R with the same set of command-line options as previously called:
restart_r <- function(status = 0, debug = TRUE) {
if (debug) message("restart_r(): Customizing .Last() to relaunch R ...")
assign(".Last", function() {
args <- commandArgs()
system2(args[1], args = args[-1])
}, envir = globalenv())
if (debug) message("restart_r(): Quitting current R session and starting a new one ...")
quit(save = "no", status = status, runLast = TRUE)
}
I needed the same refresh session functionality on windows and I ended up with a slightly modified version of the code:
makeActiveBinding("refresh", function() { shell(paste0("start \"\" \"", R.home(), "/bin/x64/Rgui.exe\"")); q("no") }, .GlobalEnv)
On windows you need to modify the Rprofile.site file. It is under R's etc directory. Also watch out for the last part of the path the bin/x64 can change according to your system configuration. I hope this will help others too.
I think, one realizes the best use of R by setting a current working directory in options. Then whenever your workspace /session file starts showing you up or has enough of your work in it (in between projects) you can just rename this default session file in the working directory after closing R and R/Rstudio will automatically start you in a new workspace/session file, without disturbing your current work.
Remember to quit R and rename the current session file
Of course if you do not want to save the current work you have to make sure you reset objects or operations on them were done after copying from original objects so they are as is. Trust me, knowing you can always load the old workspaces is a temptation but is more useful than not.
In short quit R, it gives you some gap while quitting means this workspace is full, rename it after completing the quit and restart R/Rstudio with a fresh workspace. You can always load select objects in the new workspace. Ideally all important work should be in Project directories but you still need a history of your jobs to go back to at times and saved sessions come in useful at some point once you are on longer projects. If you don't need any of it just rm(list=ls())
Also, I like the RDComClient idea by #Eduardo Alvin but it has been discontinued.
ALTERNATIVE OPTION
A simple alternative to get rid of the baggage at any time inside your workspace is to use save.image
save.image("Rstreamingscience.data")
quit(save='no')
load("Rstreamingscience.data") ##G:/ADA registers##
save.image("Rstreamingscience.data")
This leaves you free to come and go as you please and open as many workspaces as you need.
makeActiveBinding("refresh", function() { system(paste0(R.home(),"/bin/i386/R")); q("no") }, .GlobalEnv)
or with --save or --no-save
paste0(R.home(),"/bin/i386/R --no-save")
I think this is what you need if you've used setwd() before calling refresh (although neither this nor the original version works for me, since it restarts R then closes itself, a new window is never opened. If anyone can comment on this, please do so)
I have written the following function.
Remember! You can only use it once, then you have to reload it after the R session restarts.
clc <- function() {
rm(list = ls(envir = globalenv()),envir = globalenv()) #clear Vars from global enviroment
gc() #grabage colector
cat("\014") #clc
.rs.restartR() #clear session
}
Sometimes detaching a package also helps.