विशेषज्ञ आर उपयोगकर्ता, आपके .Rprofile में क्या है? [बन्द है]

Question

मुझे हमेशा भाषा के बारे में उपयोगी और शिक्षाप्रद दोनों अन्य लोगों की स्टार्टअप प्रोफाइल फाइलें मिली हैं। इसके अलावा, जबकि मेरे पास बैश और विम के लिए कुछ अनुकूलन है , मेरे पास आर के लिए कुछ भी नहीं है।

उदाहरण के लिए, एक चीज जो मैं हमेशा चाहता था, वह है विंडो टर्मिनल में इनपुट और आउटपुट टेक्स्ट के लिए अलग-अलग रंग, और शायद सिंटैक्स हाइलाइटिंग भी।

Comments

दुर्भाग्य से सवाल बंद है, लेकिन मुझे दृढ़ता से लगता है कि सही उत्तर "कुछ नहीं" है। उपयोग करने के बजाय .Rprofile, मैं सुझाव देता हूं कि प्रत्येक प्रोजेक्ट के शीर्ष स्तर पर एक इनिशियलाइज़ेशन स्क्रिप्ट रखें जो आपके प्रोजेक्ट में प्रत्येक स्क्रिप्ट की शुरुआत में इसे प्राप्त करता है। स्रोत नियंत्रण के माध्यम से अन्य उपयोगकर्ताओं के बीच आपका काम प्रजनन योग्य रहता है। लेकिन, यहाँ कुछ शानदार जवाब हैं! मैं इन विचारों में से कुछ को अपनी इनिशियलाइज़ेशन स्क्रिप्ट (ओं) में रखूँगा।

— जिन्नोरमा 11'14

@geneorama - अच्छी टिप्पणी लेकिन मैं आपके उत्तर को थोड़ा अर्हता प्राप्त करूंगा: .Rprofileपरिणामों को बदलने वाले किसी भी कोड को शामिल नहीं करना चाहिए। आप जो शामिल कर सकते हैं वह सामान है जो आर (जैसे options("width"=160)) या डिफ़ॉल्ट सीआरएएन दर्पण (जैसे options(repos = c(CRAN = "http://cran.rstudio.com"))) की उपस्थिति को बदलता है । हालांकि, पैकेजों को लोड न करें, नियमित रूप से उपयोग किए जाने वाले कार्यों के डिफ़ॉल्ट विकल्पों को बदलें, फ़ंक्शन को परिभाषित करें आदि आपका कोड स्वयं होना चाहिए और आपकी विशेष .Rprofileफ़ाइल के बिना परिणामों को पुन: उत्पन्न करना चाहिए ।

— user2503795

@ गेनोरमा, मुझे कस्टम फ़ंक्शंस कहाँ से लाने चाहिए? शायद एक अलग पैकेज / नेमस्पेस में? क्या यह आसान / संभव है .Rprofile?

— एरॉन मैकडैड

@ aaron-mcdaid फर्स्ट @ user2503795 बिल्कुल सही है, .Rprofileएप्लिकेशन परिवर्तन करने के लिए एक उपयुक्त स्थान है। दूसरा, आपका प्रश्न एक अलग SO प्रश्न होना चाहिए। मैं अपने खाद्य निरीक्षण परियोजना में जो कुछ भी किया था, उसके समान पैटर्न का उपयोग करने की कोशिश करता हूं (प्रत्येक स्क्रिप्ट के शीर्ष पर कोड लेआउट और प्रारंभिक चरण देखें)।

— जीनोरमा 19

Answer 1

यह रहा मेरा। यह आपको रंग भरने में मदद नहीं करेगा, लेकिन मुझे ईएसएस और एमएसीएस से ...

options("width"=160)                # wide display with multiple monitors
options("digits.secs"=3)            # show sub-second time stamps

r <- getOption("repos")             # hard code the US repo for CRAN
r["CRAN"] <- "http://cran.us.r-project.org"
options(repos = r)
rm(r)

## put something this is your .Rprofile to customize the defaults
setHook(packageEvent("grDevices", "onLoad"),
        function(...) grDevices::X11.options(width=8, height=8, 
                                             xpos=0, pointsize=10, 
                                             #type="nbcairo"))  # Cairo device
                                             #type="cairo"))    # other Cairo dev
                                             type="xlib"))      # old default

## from the AER book by Zeileis and Kleiber
options(prompt="R> ", digits=4, show.signif.stars=FALSE)


options("pdfviewer"="okular")         # on Linux, use okular as the pdf viewer

Comments

मुझे यकीन नहीं है, लेकिन मुझे लगता है कि अब X11.options को windows.options द्वारा बदल दिया गया है। क्या यह सच है?

— मैनुअल रामोन

इसे बनाने rऔर फिर- करने के बजाय rm, आप इसे एक local({ })ब्लॉक के अंदर रख सकते हैं । हालांकि अच्छा जवाब, मुझे X11 कॉन्फिग पसंद है!

— हारून मैकडैड

हाँ, local({ ... })जैसा कि दिखाया गया help(Startup)है कि मैं आमतौर पर इन दिनों में क्या करता हूँ Rprofile.site। थोड़ी देर में X11 हैक की जरूरत नहीं थी :)

— डिर्क एडल्डबुलेटेल

Answer 2

options(stringsAsFactors=FALSE)

हालांकि मेरे पास वास्तव में ऐसा नहीं है कि मेरे .Rprofile में, क्योंकि यह मेरे coauthors के कोड को तोड़ सकता है, काश यह डिफ़ॉल्ट होता। क्यों?

1) चरित्र वैक्टर कम मेमोरी का उपयोग करते हैं (लेकिन केवल मुश्किल से);

2) अधिक महत्वपूर्ण बात, हम इस तरह की समस्याओं से बचना होगा:

> x <- factor(c("a","b","c"))
> x
[1] a b c
Levels: a b c
> x <- c(x, "d")
> x
[1] "1" "2" "3" "d"

तथा

> x <- factor(c("a","b","c"))
> x[1:2] <- c("c", "d")
Warning message:
In `[<-.factor`(`*tmp*`, 1:2, value = c("c", "d")) :
  invalid factor level, NAs generated

जब आपको उनकी आवश्यकता होती है तो कारक महान होते हैं (जैसे ग्राफ़ में आदेश को लागू करना) लेकिन अधिकांश समय एक उपद्रव।

Comments

एडुआर्डो - दिलचस्प है, कारकों का उपयोग न करने के क्या फायदे हैं?

— 18

+1 की इच्छा है कि यह आर। में डिफ़ॉल्ट था

— इटरेटर

ध्यान दें कि वर्ण वैक्टर केवल 32-बिट सिस्टम पर कम मेमोरी (दो सौ बाइट्स या तो) का उपयोग करते हैं। 64-बिट सिस्टम कारकों पर काफी कम उपयोग करते हैं। stat.ethz.ch/pipermail/r-help/2012-August/321919.html

— अरी बी। फ्रीडमैन

+1 कारकों के साथ कुछ प्रमुख मुद्दों को इंगित करने के लिए धन्यवाद। एसएएस के प्रारूप प्रणाली में इस पर कई फायदे हैं, इमो। पाठ से पढ़ते समय, स्ट्रिंग्सएफ़एक्टर्स हमेशा गलत पर सेट होते हैं। हालाँकि, डेटा ट्रांसफर के लिए, मैं जहाँ भी संभव हो, स्प्रेडशीट पढ़ने से बचता हूँ।

— एडम जूल

Answer 3

मुझे हर बार पूर्ण शब्द 'हेड', 'सारांश', 'नाम' टाइप करने से नफरत है, इसलिए मैं उपनाम का उपयोग करता हूं।

आप अपने .Rprofile फ़ाइल में उपनाम रख सकते हैं, लेकिन आपको फ़ंक्शन के लिए पूर्ण पथ का उपयोग करना होगा (जैसे बर्तन :: सिर) अन्यथा यह काम नहीं करेगा।

# aliases
s <- base::summary
h <- utils::head
n <- base::names

संपादित करें: अपने प्रश्न का उत्तर देने के लिए, आप टर्मिनल में अलग-अलग रंगों के लिए कलरआउट पैकेज का उपयोग कर सकते हैं । ठंडा! :-)

Comments

मुझे लगता है nकि मुझे डिबगिंग करते समय, व्यक्तिगत रूप से, पीछे की ओर काट दिया जाएगा।

— बजे रोमन लुसट्रिक

इंटरेक्टिव आर उपयोग के लिए ठीक है, लेकिन ये पोर्टेबल नहीं हैं - उन्हें अपने (लिखित) कोड में न डालें!

— विंस

यदि आप कभी भी अपने वैश्विक वातावरण में सभी वस्तुओं को हटाते हैं, तो ऊपर दिए गए उपनाम भी हटा दिए जाएंगे। आप इसे एक वातावरण में छिपाकर इसे रोक सकते हैं। .startup <- new.env() assign("h", utils::head, env=.startup) assign("n", base::names, env=.startup) assign("ht", function(d) rbind(head(d,6),tail(d,6)) , env=.startup) assign("s", base::summary, env=.startup) attach(.startup)

— केविन राइट

मैं इस महान विचार की कोशिश की, लेकिन मैं पहले से ही इस्तेमाल किया तो मैंने किया sum <- base::summary। यह इतना अच्छा विचार नहीं था ।

— टॉम

पुन colorout: "" "इस पैकेज को संग्रहीत किया गया है: इसमें CRAN नीतियों द्वारा अनुमति नहीं दी गई गैर-एपीआई प्रविष्टि बिंदुओं का उपयोग किया गया।" ""

— isomorphismes

Answer 4

ये मेरा। मैं हमेशा मुख्य क्रेन रिपॉजिटरी का उपयोग करता हूं, और स्रोत-इन-डेवलपमेंट पैकेज कोड को आसान बनाने के लिए कोड है।

.First <- function() {
    library(graphics)
    options("repos" = c(CRAN = "http://cran.r-project.org/"))
    options("device" = "quartz")
}

packages <- list(
  "describedisplay" = "~/ggobi/describedisplay",
  "linval" = "~/ggobi/linval", 

  "ggplot2" =  "~/documents/ggplot/ggplot",
  "qtpaint" =  "~/documents/cranvas/qtpaint", 
  "tourr" =    "~/documents/tour/tourr", 
  "tourrgui" = "~/documents/tour/tourr-gui", 
  "prodplot" = "~/documents/categorical-grammar"
)

l <- function(pkg) {
  pkg <- tolower(deparse(substitute(pkg)))
  if (is.null(packages[[pkg]])) {
    path <- file.path("~/documents", pkg, pkg)
  } else {
    path <- packages[pkg]
  }

  source(file.path(path, "load.r"))  
}

test <- function(path) {
  path <- deparse(substitute(path))
  source(file.path("~/documents", path, path, "test.r"))  
}

Answer 5

मैं अपने R कमांड इतिहास को सहेजना पसंद करता हूं और इसे हर बार उपलब्ध होने के बाद मैं R चलाता हूं:

शेल या .bashrc में:

export R_HISTFILE=~/.Rhistory

,

.Last <- function() {
        if (!any(commandArgs()=='--no-readline') && interactive()){
                require(utils)
                try(savehistory(Sys.getenv("R_HISTFILE")))
        }
}

Answer 6

यहाँ दो कार्य हैं जो मैं विंडोज़ के साथ काम करने के लिए काम करता हूँ।

पहले \एस को धर्मान्तरित करता है /।

.repath <- function() {
   cat('Paste windows file path and hit RETURN twice')
   x <- scan(what = "")
   xa <- gsub('\\\\', '/', x)
   writeClipboard(paste(xa, collapse=" "))
   cat('Here\'s your de-windowsified path. (It\'s also on the clipboard.)\n', xa, '\n')
 }

दूसरा एक नई एक्सप्लोरर विंडो में कार्यशील निर्देशिका को खोलता है।

getw <- function() {
    suppressWarnings(shell(paste("explorer",  gsub('/', '\\\\', getwd()))))
}

Comments

यह .repathहै तो मेरी .Rprofile में हो रही।

— वाल्डिर लियोनसियो

मैंने एक RStudio एडिन लिखा है जिसमें यह सुविधा शामिल है। आप बस पथ की प्रतिलिपि बनाएँ, RStudio से एक मेनू पर क्लिक करें, और परिवर्तित पथ आपके कर्सर स्थान में डाला जाएगा। इससे कुछ कीस्ट्रोक्स को बचाना चाहिए।

— डेराकोडोक

मुझे विंडोज़ पथ के मुद्दे से बहुत नफरत है। मुझे लगता है कि मेरे पास एक बेहतर समाधान भी हो सकता है। मैंने एक स्निपेट जोड़ा। तो मुझे बस इतना करना है कि wpp टाइप करें और फिर टैब दबाएं और मेरा कॉपी किया हुआ रास्ता दिखाता है। यहाँ कोड है। snippet wpp `r paste("\"", gsub("\\\\", "/", readClipboard()), "\"", sep = "")`

— jamesguy0121

Answer 7

मुझे यह मिला है, पूर्ण टर्मिनल चौड़ाई का उपयोग करने के लिए अधिक गतिशील चाल, जो COLUMNS पर्यावरण चर (लिनक्स पर) से पढ़ने की कोशिश करता है:

tryCatch(
  {options(
      width = as.integer(Sys.getenv("COLUMNS")))},
  error = function(err) {
    write("Can't get your terminal width. Put ``export COLUMNS'' in your \
           .bashrc. Or something. Setting width to 120 chars",
           stderr());
    options(width=120)}
)

इस तरह आर पूरी चौड़ाई का उपयोग करेगा यहां तक ​​कि जब आप अपनी टर्मिनल विंडो का आकार बदलते हैं।

Comments

जब COLUMNSसेट नहीं किया जाता है, तो आप width = as.integer(system('tput cols',intern=TRUE)बैकस्टॉप के रूप में कोशिश कर सकते हैं ।

— shabbychef

Answer 8

मेरे अधिकांश व्यक्तिगत कार्य और भरी हुई लाइब्रेरी Rfunctions.r स्क्रिप्ट में हैं

source("c:\\data\\rprojects\\functions\\Rfunctions.r")


.First <- function(){
   cat("\n Rrrr! The statistics program for Pirates !\n\n")

  }

  .Last <- function(){
   cat("\n Rrrr! Avast Ye, YO HO!\n\n")

  }


#===============================================================
# Tinn-R: necessary packages
#===============================================================
library(utils)
necessary = c('svIDE', 'svIO', 'svSocket', 'R2HTML')
if(!all(necessary %in% installed.packages()[, 'Package']))
  install.packages(c('SciViews', 'R2HTML'), dep = T)

options(IDE = 'C:/Tinn-R/bin/Tinn-R.exe')
options(use.DDE = T)

library(svIDE)
library(svIO)
library(svSocket)
library(R2HTML)
guiDDEInstall()
shell(paste("mkdir C:\\data\\rplots\\plottemp", gsub('-','',Sys.Date()), sep=""))
pldir <- paste("C:\\data\\rplots\\plottemp", gsub('-','',Sys.Date()), sep="")

plot.str <-c('savePlot(paste(pldir,script,"\\BeachSurveyFreq.pdf",sep=""),type="pdf")')

Comments

हे, मैंने एक आर जीयूआई "अर्र" का नामकरण के बारे में सोचा - यह कुछ समुद्री डाकू अच्छाई को जोड़ने का एक बहुत आसान तरीका है।

— Sharpie

आह आपका धन्यवाद। यह जानना अच्छा है कि मैं केवल एक ही नहीं हूं जो यह सोचता है कि जब आर। फायरिंग करता है, तो मुझे लगता है कि मैं इन दिनों में से एक पर पहुंच जाऊंगा।

— ars

यह बताता है कि @ डर्क अपनी स्क्रिप्ट में अपना हुक क्यों लगा रहा था ...

— जेम्स

"अवास्ट ये" गैर-मानक समुद्री डाकू है । मैं मानकों के अनुरूप अपने समुद्री डाकू को प्राथमिकता देता हूं। इसके अलावा, इसका मतलब है ~ "कसकर पकड़", तो क्या यह शुरुआत में अधिक समझ में नहीं आएगा? : पी

— naught101

वास्तव में यह अंत में सही समझ में आता है। आर डोमेन से बाहर निकलने के लिए हम इसके आस-पास कम वातावरण में लौटते हैं और फिर से स्प्रेडशीट और तदर्थ पाठ फ़ाइलों से निपटना चाहिए।

— kpierce8

Answer 9

यहाँ मेरा ~ / .Rprofile , मैक और लिनक्स के लिए डिज़ाइन किया गया है।

ये त्रुटियों को देखने में आसान बनाते हैं।

options(showWarnCalls=T, showErrorCalls=T)

मुझे CRAN मेनू पसंद से नफरत है, इसलिए एक अच्छे से सेट करें।

options(repos=c("http://cran.cnr.Berkeley.edu","http://cran.stat.ucla.edu"))

अधिक इतिहास!

Sys.setenv(R_HISTSIZE='100000')

निम्नलिखित टर्मिनल से मैक OSX पर चलने के लिए है (जिसे मैं R.app को बहुत पसंद करता हूं क्योंकि यह अधिक स्थिर है, और आप निर्देशिका द्वारा अपना काम व्यवस्थित कर सकते हैं; एक अच्छा ~ / .inputrc प्राप्त करना भी सुनिश्चित करें )। डिफ़ॉल्ट रूप से, आपको X11 डिस्प्ले मिलता है, जो उतना अच्छा नहीं लगता है; इसके बजाय यह GUI के समान ही क्वार्ट्ज डिस्प्ले देता है। यह ifकथन उस मामले को पकड़ने वाला है जब आप मैक पर टर्मिनल से आर चला रहे हैं।

f = pipe("uname")
if (.Platform$GUI == "X11" && readLines(f)=="Darwin") {
  # http://www.rforge.net/CarbonEL/
  library("grDevices")
  library("CarbonEL")
  options(device='quartz')
  Sys.unsetenv("DISPLAY")
}
close(f); rm(f)

और कुछ पुस्तकालयों को प्रीलोड करें,

library(plyr)
library(stringr)
library(RColorBrewer)
if (file.exists("~/util.r")) {
  source("~/util.r")
}

जहां util.r प्रवाह के तहत सामान मैं उपयोग की एक यादृच्छिक बैग है।

इसके अलावा, चूंकि अन्य लोग कंसोल की चौड़ाई का उल्लेख कर रहे थे, यहां बताया गया है कि मैं यह कैसे करता हूं।

if ( (numcol <-Sys.getenv("COLUMNS")) != "") {
  numcol = as.integer(numcol)
  options(width= numcol - 1)
} else if (system("stty -a &>/dev/null") == 0) {
  # mac specific?  probably bad in the R GUI too.
  numcol = as.integer(sub(".* ([0-9]+) column.*", "\\1", system("stty -a", intern=T)[1]))
  if (numcol > 0)
    options(width=  numcol - 1 )
}
rm(numcol)

यह वास्तव में नहीं है .Rprofileक्योंकि आपको हर बार टर्मिनल विंडो के आकार बदलने के बाद इसे फिर से चलाना होगा। मेरे पास यह है util.rतो मैं इसे आवश्यक रूप से स्रोत बनाता हूं।

Comments

अगर मैं एक xterm विंडो में R खोलता हूं ("R" टाइप करके) क्या यह R gui जैसी विंडो खोलनी चाहिए? मैं इसे जोड़कर कोई अंतर नहीं बता सकता। मेरे घर की निर्देशिका में लाभकारी।

— रिचर्ड हेरॉन 21

नहीं, यह क्या है, यह सब कुछ कंसोल में रखता है। हालाँकि, जब आप चीजों को प्लॉट करते हैं, तो यह डिफ़ॉल्ट X11 डिस्प्ले डिवाइस की तुलना में एक स्मार्ट डिस्प्ले डिवाइस का उपयोग करता है।

— ब्रेंडन OConnor

मुझे लगता है कि ये विंडो-आकार बदलने वाली स्क्रिप्ट उपयोगी रूप से एक पैकेज हो सकती है। क्या आप सहमत हैं?

— isomorphismes 5

Answer 10

यहाँ मेरा हैं:

.First <- function () {
  options(device="quartz")
}

.Last <- function () {
  if (!any(commandArgs() == '--no-readline') && interactive()) {
    require(utils)
    try(savehistory(Sys.getenv("R_HISTFILE")))
  }
}

# Slightly more flexible than as.Date
# my.as.Date("2009-01-01") == my.as.Date(2009, 1, 1) == as.Date("2009-01-01")
my.as.Date <- function (a, b=NULL, c=NULL, ...) {
  if (class(a) != "character")
    return (as.Date(sprintf("%d-%02d-%02d", a, b, c)))
  else
    return (as.Date(a))
}

# Some useful aliases
cd <- setwd
pwd <- getwd
lss <- dir
asd <- my.as.Date # examples: asd("2009-01-01") == asd(2009, 1, 1) == as.Date("2009-01-01")
last <- function (x, n=1, ...) tail(x, n=n, ...)

# Set proxy for all web requests
Sys.setenv(http_proxy="http://192.168.0.200:80/")

# Search RPATH for file <fn>.  If found, return full path to it
search.path <- function(fn,
     paths = strsplit(chartr("\\", "/", Sys.getenv("RPATH")), split =
                switch(.Platform$OS.type, windows = ";", ":"))[[1]]) {
  for(d in paths)
     if (file.exists(f <- file.path(d, fn)))
        return(f)
  return(NULL)
}

# If loading in an environment that doesn't respect my RPATH environment
# variable, set it here
if (Sys.getenv("RPATH") == "") {
  Sys.setenv(RPATH=file.path(path.expand("~"), "Library", "R", "source"))
}

# Load commonly used functions
if (interactive())
  source(search.path("afazio.r"))

# If no R_HISTFILE environment variable, set default
if (Sys.getenv("R_HISTFILE") == "") {
  Sys.setenv(R_HISTFILE=file.path("~", ".Rhistory"))
}

# Override q() to not save by default.
# Same as saying q("no")
q <- function (save="no", ...) {
  quit(save=save, ...)
}

# ---------- My Environments ----------
#
# Rather than starting R from within different directories, I prefer to
# switch my "environment" easily with these functions.  An "environment" is
# simply a directory that contains analysis of a particular topic.
# Example usage:
# > load.env("markets")  # Load US equity markets analysis environment
# > # ... edit some .r files in my environment
# > reload()             # Re-source .r/.R files in my environment
#
# On next startup of R, I will automatically be placed into the last
# environment I entered

# My current environment
.curr.env = NULL

# File contains name of the last environment I entered
.last.env.file = file.path(path.expand("~"), ".Rlastenv")

# Parent directory where all of my "environment"s are contained
.parent.env.dir = file.path(path.expand("~"), "Analysis")

# Create parent directory if it doesn't already exist
if (!file.exists(.parent.env.dir))
  dir.create(.parent.env.dir)

load.env <- function (string, save=TRUE) {
  # Load all .r/.R files in <.parent.env.dir>/<string>/
  cd(file.path(.parent.env.dir, string))
  for (file in lss()) {
    if (substr(file, nchar(file)-1, nchar(file)+1) %in% c(".r", ".R"))
      source(file)
  }
  .curr.env <<- string
  # Save current environment name to file
  if (save == TRUE) writeLines(.curr.env, .last.env.file)
  # Let user know environment switch was successful
  print (paste(" -- in ", string, " environment -- "))
}

# "reload" current environment.
reload <- resource <- function () {
  if (!is.null(.curr.env))
    load.env(.curr.env, save=FALSE)
  else
    print (" -- not in environment -- ")
}

# On startup, go straight to the environment I was last working in
if (interactive() && file.exists(.last.env.file)) {
  load.env(readLines(.last.env.file))
}

Comments

आपको किसी सार्वजनिक वेबसाइट पर अपने संस्थान के प्रॉक्सी का पता पोस्ट नहीं करना चाहिए।

— dalloliogm

dalloliogm, यह एक निजी (गैर सार्वजनिक) आईपी पता है। इस सटीक आईपी पते के साथ दुनिया भर में सैकड़ों हजारों कंप्यूटर हैं। सौभाग्य यह जानने की कोशिश कर रहा है कि कौन सा मेरा है!

— अल्फ्रेड जे फाज़ियो

अल्फ्रेड, क्या आपने कार्यों को परिभाषित करने का एक तरीका खोजा है। (जब आप यहाँ हैं) के रूप में (जब आप यहाँ हैं) उन्हें दिखाते हैं कि जब आप एक ls () करते हैं, तो एक प्रारंभिक नाम के साथ एक तरफ। '' मेरे पास उन कार्यों से बहुत अधिक अव्यवस्था है जिन्हें मैंने ls () के समय परिभाषित किया था। साभार

— कीथ

@ उन्हें पर्यावरण के लिए असाइन करें और खोज पथ पर पर्यावरण को संलग्न करें, फिर साफ करें। यदि फ़ंक्शन एक अलग फ़ाइल में हैं, तो आप सीधे पर्यावरण में स्रोत कर सकते हैं। देखें ?new.env, ?assignऔर ?sys.source। यदि आप इसे काम पर नहीं ला सकते हैं, तो SO पर एक नया Q पोस्ट करें और मुझे यकीन है कि आपको उत्तर मिल जाएंगे।

— गेविन सिम्पसन

आपका my.as.Dateद्वारा ले जा सकता है Lubridateपैकेज। क्या मैं सही हू?

— isomorphismes

Answer 11

sink(file = 'R.log', split=T)

options(scipen=5)

.ls.objects <- function (pos = 1, pattern, order.by = "Size", decreasing=TRUE, head =     TRUE, n = 10) {
  # based on postings by Petr Pikal and David Hinds to the r-help list in 2004
  # modified by: Dirk Eddelbuettel (http://stackoverflow.com/questions/1358003/tricks-to-    manage-the-available-memory-in-an-r-session) 
  # I then gave it a few tweaks (show size as megabytes and use defaults that I like)
  # a data frame of the objects and their associated storage needs.
  napply <- function(names, fn) sapply(names, function(x)
          fn(get(x, pos = pos)))
  names <- ls(pos = pos, pattern = pattern)
  obj.class <- napply(names, function(x) as.character(class(x))[1])
  obj.mode <- napply(names, mode)
  obj.type <- ifelse(is.na(obj.class), obj.mode, obj.class)
  obj.size <- napply(names, object.size) / 10^6 # megabytes
  obj.dim <- t(napply(names, function(x)
            as.numeric(dim(x))[1:2]))
  vec <- is.na(obj.dim)[, 1] & (obj.type != "function")
  obj.dim[vec, 1] <- napply(names, length)[vec]
  out <- data.frame(obj.type, obj.size, obj.dim)
  names(out) <- c("Type", "Size", "Rows", "Columns")
  out <- out[order(out[[order.by]], decreasing=decreasing), ]
  if (head)
    out <- head(out, n)
  out
}

Answer 12

केवल 'हेड' टाइप करने के लिए डेटा.फ्रेम को 'हेड' की तरह प्रदर्शित करें

print.data.frame <- function(df) {
   if (nrow(df) > 10) {
      base::print.data.frame(head(df, 5))
      cat("----\n")
      base::print.data.frame(tail(df, 5))
   } else {
      base::print.data.frame(df)
   }
}

( आउटपुट से 'हेड' को स्वचालित रूप से कैसे लागू किया जाए? )

Answer 13

मेरे पास अक्सर डिबग कॉल की एक श्रृंखला होती है, जिन्हें मुझे कॉल करने की आवश्यकता होती है और उन्हें अनियंत्रित करना बहुत थकाऊ हो सकता है। एसओ समुदाय की मदद से , मैं निम्नलिखित समाधान के लिए गया और इसे अपने में सम्मिलित किया .Rprofile.site। # BROWSERक्या मेरे ग्रहण कार्य के लिए इतना है कि मेरे पास टास्क व्यू विंडो में ब्राउज़र कॉल का अवलोकन है।

# turn debugging on or off
# place "browser(expr = isTRUE(getOption("debug"))) # BROWSER" in your function
# and turn debugging on or off by bugon() or bugoff()
bugon <- function() options("debug" = TRUE)
bugoff <- function() options("debug" = FALSE) #pun intended

Answer 14

मेरा भी फैंसी नहीं है:

# So the mac gui can find latex
Sys.setenv("PATH" = paste(Sys.getenv("PATH"),"/usr/texbin",sep=":"))

#Use last(x) instead of x[length(x)], works on matrices too
last <- function(x) { tail(x, n = 1) }

#For tikzDevice caching 
options( tikzMetricsDictionary='/Users/cameron/.tikzMetricsDictionary' )

Answer 15

setwd("C://path//to//my//prefered//working//directory")
library("ggplot2")
library("RMySQL")
library("foreign")
answer <- readline("What database would you like to connect to? ")
con <- dbConnect(MySQL(),user="root",password="mypass", dbname=answer)

मैं mysql डेटाबेस से बहुत काम करता हूं, इसलिए तुरंत कनेक्ट करना एक Godsend है। मैं केवल यह चाहता हूं कि अव्यावहारिक डेटाबेस को सूचीबद्ध करने का एक तरीका था, इसलिए मुझे सभी विभिन्न नामों को याद नहीं करना होगा।

Comments

मूर्खतापूर्ण मुझे dbGetQuery (चुनाव, "डेटाबेस दिखाएं;")

— ब्रैंडन बर्टेल्सन

Answer 16

स्टीफन टर्नर की पोस्ट पर। लाभार्थियों के कई उपयोगी उपनाम और स्टार्टर फ़ंक्शन हैं।

मैं अपने आप को अक्सर अपने ht और hh का उपयोग करते हुए पाता हूं।

#ht==headtail, i.e., show the first and last 10 items of an object
ht <- function(d) rbind(head(d,10),tail(d,10))

# Show the first 5 rows and first 5 columns of a data frame or matrix
hh <- function(d) d[1:5,1:5]

Comments

वहाँ एक पैकेज है जिसे बुर्स्टिमस्क कहा जाता है जिसमें एक फ़ंक्शन होता है जिसे कहा जाता है cornerजो आपके hhफ़ंक्शन और थोड़ा और अधिक के समान है। ;)

— वाल्डिर लियोनसियो

Answer 17

यहाँ मेरा कुछ उल्लेखित विचारों सहित है।

दो चीजें जिन्हें आप देखना चाहते हैं:

• .set.width () / w () टर्मिनल के एक में अपनी प्रिंट चौड़ाई को अपडेट करें। दुर्भाग्य से मुझे टर्मिनल आकार पर स्वचालित रूप से ऐसा करने का कोई तरीका नहीं मिला - आर प्रलेखन में उल्लेख है कि यह कुछ आर दुभाषियों द्वारा किया जाता है।
• टाइमस्टैम्प और वर्किंग डायरेक्टरी के साथ इतिहास को हर बार सहेजा जाता है

।

.set.width <- function() {
  cols <- as.integer(Sys.getenv("COLUMNS"))
  if (is.na(cols) || cols > 10000 || cols < 10)
    options(width=100)
  options(width=cols)
}

.First <- function() {
  options(digits.secs=3)              # show sub-second time stamps
  options(max.print=1000)             # do not print more than 1000 lines
  options("report" = c(CRAN="http://cran.at.r-project.org"))
  options(prompt="R> ", digits=4, show.signif.stars=FALSE)
}

# aliases
w <- .set.width

.Last <- function() {
  if (!any(commandArgs()=='--no-readline') && interactive()){
    timestamp(,prefix=paste("##------ [",getwd(),"] ",sep=""))
    try(savehistory("~/.Rhistory"))
   }
}

Answer 18

मैं कैशस्टेव (या pgfSweave) पाने के लिए निम्नलिखित का उपयोग RStudio में "कंपाइल पीडीएफ" बटन के साथ काम करने के लिए करता हूं:

library(cacheSweave)
assignInNamespace("RweaveLatex", cacheSweave::cacheSweaveDriver, "utils")

Answer 19

मेरा शामिल है options(menu.graphics=FALSE)क्योंकि मैं R में CRAN दर्पण चयन के लिए tcltk पॉपअप को अक्षम / दबा देना पसंद करता हूं ।

Answer 20

ये मेरा। कुछ भी नवीन नहीं। विशेष विकल्प पर विचार:

• मैं इसके लिए एक डिफ़ॉल्ट सेट करने के साथ गया था stringsAsFactorsक्योंकि मुझे लगता है कि इसे एक तर्क के रूप में पारित करने के लिए हर बार जब मैं एक सीएसवी पढ़ता हूं तो यह बहुत ही कम होता है। उस ने कहा, इससे पहले ही मुझे कंप्यूटर पर मेरे सामान्य कंप्यूटर पर लिखे गए कोड का उपयोग करते समय मुझे कुछ मामूली चोट लगी है। मेरे पास नहीं था। मैं इसे रख रहा हूँ, हालांकि, मुसीबतों के रूप में यह मुसीबतों की तुलना में पीला हो गया है क्योंकि इसे हर रोज सेट करने के लिए उपयोग नहीं किया जाता है।
• यदि आप utilsपहले पैकेज लोड नहीं करते हैं options(error=recover), तो interactive()ब्लॉक के अंदर रखने पर यह ठीक नहीं हो सकता ।
• मैंने .dbइसके बजाय अपने ड्रॉपबॉक्स सेटिंग के लिए उपयोग किया options(dropbox=...)क्योंकि मैं इसे हर समय अंदर उपयोग करता हूं file.pathऔर यह बहुत टाइपिंग बचाता है। अग्रणी .इसे प्रदर्शित होने से रोकता है ls()।

बिना और देरी के:

if(interactive()) {
    options(stringsAsFactors=FALSE)
    options(max.print=50)
    options(repos="http://cran.mirrors.hoobly.com")
}

.db <- "~/Dropbox"
# `=` <- function(...) stop("Assignment by = disabled, use <- instead")
options(BingMapsKey="blahblahblah") # Used by taRifx.geo::geocode()

.First <- function() {
    if(interactive()) {
        require(functional)
        require(taRifx)
        require(taRifx.geo)
        require(ggplot2)
        require(foreign)
        require(R.utils)
        require(stringr)
        require(reshape2)
        require(devtools)
        require(codetools)
        require(testthat)
        require(utils)
        options(error=recover)
    }
}

Answer 21

यहाँ LaTeX को एक्सपोर्टिंग टेबल के लिए थोड़ा स्निपेट दिया गया है । यह मेरे द्वारा लिखी गई कई रिपोर्टों के लिए सभी कॉलम नामों को गणित मोड में बदल देता है। मेरे बाकी .Rprofile बहुत मानक है और ज्यादातर ऊपर कवर किया गया है।

# Puts $dollar signs in front and behind all column names col_{sub} -> $col_{sub}$

amscols<-function(x){
    colnames(x) <- paste("$", colnames(x), "$", sep = "")
    x
}

Answer 22

मैंने अपनी प्रोफ़ाइल में अपना जाली रंग विषय निर्धारित किया है। यहाँ दो अन्य ट्वीक्स हैं जिनका मैं उपयोग करता हूँ:

# Display working directory in the titlebar
# Note: This causes demo(graphics) to fail
utils::setWindowTitle(base::getwd())
utils::assignInNamespace("setwd",function(dir)   {.Internal(setwd(dir));setWindowTitle(base::getwd())},"base")

# Don't print more than 1000 lines
options(max.print=2000)

Comments

यह setwdप्रतिस्थापन संस्करण में बेहतर काम करेगा:utils::assignInNamespace("setwd",function(dir) {on.exit(setWindowTitle(base::getwd())); .Internal(setwd(dir))}, "base")

— मर्क

Answer 23

मेरे पास एक पर्यावरण चर R_USER_WORKSPACE है जो मेरे पैकेजों की शीर्ष निर्देशिका को इंगित करता है। .Rprofile में, मैं एक फ़ंक्शन डेवेलिब को परिभाषित करता हूं, जो वर्किंग डायरेक्टरी (ताकि डेटा () काम करता है) और सभी .R फ़ाइलों को R उपनिर्देशिका में सेट करता है। यह हदले के एल () फ़ंक्शन के काफी समान है।

devlib <- function(pkg) {
  setwd(file.path(Sys.getenv("R_USER_WORKSPACE", "."), deparse(substitute(pkg)), "dev"))
  sapply(list.files("R", pattern=".r$", ignore.case=TRUE, full.names=TRUE), source)
  invisible(NULL)
}

.First <- function() {
  setwd(Sys.getenv("R_USER_WORKSPACE", "."))
  options("repos" = c(CRAN = "http://mirrors.softliste.de/cran/", CRANextra="http://www.stats.ox.ac.uk/pub/RWin"))
}

.Last <- function() update.packages(ask="graphics")

Answer 24

मुझे दो कार्य वास्तव में आवश्यक लगे: पहले जब मैंने debug()कई कार्यों को निर्धारित किया है और मैंने बग को हल किया है, इसलिए मैं undebug()सभी कार्यों को करना चाहता हूं - एक के बाद एक नहीं। undebug_all()समारोह स्वीकार किए जाते हैं जवाब के रूप में जोड़ा यहाँ सबसे अच्छा है।

दूसरा, जब मैंने कई कार्यों को परिभाषित किया है और मैं एक विशिष्ट चर नाम की तलाश कर रहा हूं ls(), तो फ़ंक्शन के नामों सहित, के सभी परिणामों के भीतर इसे खोजना मुश्किल है । lsnofun()समारोह तैनात यहाँ वास्तव में अच्छा है।