R: + = (plus equals) और ++ (plus plus) c ++ / c # / java, आदि से बराबर?

Question

क्या R की अवधारणा +=(प्लस बराबरी) या ++(plus plus) है जैसे c ++ / c # / others करते हैं?

Comments

जी नहीं, ऐसा करने के लिए x += 1या x++- x = x + 1काम करता है।

— जोशुआ डॉसन

Answer 1

नहीं, यह नहीं है, देखें: आर भाषा परिभाषा: ऑपरेटर्स

Answer 2

@ GregaKešpret के बाद आप एक infix ऑपरेटर बना सकते हैं:

`%+=%` = function(e1,e2) eval.parent(substitute(e1 <- e1 + e2))
x = 1
x %+=% 2 ; x

Comments

(+1), लेकिन चेतावनी का एक शब्द। टाइपिंग x = %+=% y/2रिटर्न x = (x + y)/2। कोष्ठक जोड़ना यानी x = %+=% (y/2)समस्या का हल।

— knrumsey

@knrumsey ऐसा क्यों है? मुझे लगता है कि विभाजन एक उच्च प्रक्रिया ऑपरेटर होगा।

— डेविड केली

@DavidKelley निश्चित नहीं है। मैं तुम्हारे साथ वहाँ हूँ। मैं इस मुद्दे पर एक बार एक परियोजना पर काम कर रहा था और मुझे इस मुद्दे को खोजने में एक घंटे का समय लगा।

— knrumsey

याद रखें कि आप एक फ़ंक्शन चला रहे हैं, एक जोड़ नहीं कर रहे हैं। फंक्शंस में सबसे ज्यादा मिसाल होती है, बिना कोष्ठक के यह y को पार्स करता है क्योंकि फंक्शन इनपुट विभाजन के साथ अगला चरण है। कोष्ठक श्रृंखला के शीर्ष पर (y / 2) संचालन को बढ़ाता है।

— जस्टिन

Answer 3

R की अवधारणा नहीं है increment operator(उदाहरण के लिए C में ++)। हालांकि, अपने आप को लागू करना मुश्किल नहीं है, उदाहरण के लिए:

inc <- function(x)
{
 eval.parent(substitute(x <- x + 1))
}

उस स्थिति में आप फोन करेंगे

x <- 10
inc(x)

हालाँकि, यह फंक्शन कॉल ओवरहेड का परिचय देता है, इसलिए यह अपने आप को टाइप करने की तुलना में धीमा है x <- x + 1। यदि मुझे गलत नहीं लगता increment operatorहै तो संकलक के लिए काम करना आसान बना दिया गया, क्योंकि यह कोड को सीधे मशीन भाषा के निर्देशों में बदल सकता था।

Comments

यह फ़ंक्शन मान नहीं लौटा सकता है और फिर बाद में इंक्रीमेंट की तरह इंक्रीमेंट कर सकता है। यह + = या पूर्वगामी ++ के समान है।

— मेगेट्रॉन

गलत! संकलक के काम को आसान बनाने के लिए वृद्धि शुरू नहीं की गई थी। मुख्य रूप से काउंटरों को लागू करने के लिए प्रोसेसर मेंINC निर्देश दिया गया था (cf. इंटेल सॉफ्टवेयर डेवलपर मैनुअल)। मैं जवाब अपडेट कर दूंगा।

— केनन 3'14

Answer 4

R में ये कार्य नहीं हैं क्योंकि (R में) अधिकांश वस्तुएँ अपरिवर्तनीय हैं। वे नहीं बदलते। आमतौर पर, जब ऐसा लगता है कि आप किसी वस्तु को संशोधित कर रहे हैं, तो आप वास्तव में एक प्रति संशोधित कर रहे हैं।

Comments

जबकि अपरिवर्तनीयता वस्तुओं के लिए एक महान / वांछनीय संपत्ति है (पढ़ें: कम बग) मुझे नहीं लगता कि अपरिवर्तनशीलता + = प्रश्न से संबंधित है। अन्य भाषाओं में + = को अपरिवर्तनीय प्रकारों (जैसे .net में तार) पर लागू किया जा सकता है। ऑपरेशन बस एक नई वस्तु बनाता है और उस नई वस्तु को दिए गए चर को असाइन करता है। अपरिवर्तनीयता बनाए रखी जाती है और चर को अद्यतन किया जाता है।

— SFun28

अच्छी बात। अपरिवर्तनशीलता निश्चित रूप से इस तरह के ऑपरेशन को कम स्वाभाविक बनाती है, हालाँकि।

— हैडली

Answer 5

10 से वृद्धि और गिरावट।

require(Hmisc)
inc(x) <- 10 

dec(x) <- 10

Comments

ये फ़ंक्शन Hmisc4.1.0 संस्करण के रूप में निकाले गए प्रतीत होते हैं ।

— llasram

@llasram उस अंकन को देख रहा है, मैं किसी को दोष नहीं दे सकता।

— BERS

Answer 6

हमने इस तरह की चीज़ों की मदद के लिए एक पैकेज, रैपर, जारी किया। आप इसके बारे में और अधिक यहाँ पढ़ सकते हैं: https://happylittlescripts.blogspot.com/2018/09/make-your-r-code-nicer-with-roperators.html

install.packages('roperators')
require(roperators)

x <- 1:3
x %+=% 1; x
x %-=% 3; x
y <- c('a', 'b', 'c')
y %+=% 'text'; y
y %-=% 'text'; y

# etc

Answer 7

हम ओवरराइड कर सकते हैं +। यदि unary +का उपयोग किया जाता है और इसका तर्क स्वयं एक unary +call है, तो कॉलिंग परिवेश में संबंधित चर को बढ़ाएँ।

`+` <- function(e1,e2){
    # if unary `+`, keep original behavior
    if(missing(e2)) {
      s_e1 <- substitute(e1)
      # if e1 (the argument of unary +) is itself an unary `+` operation
      if(length(s_e1) == 2 && 
         identical(s_e1[[1]], quote(`+`)) && 
         length(s_e1[[2]]) == 1){
        # increment value in parent environment
        eval.parent(substitute(e1 <- e1 + 1,list(e1 = s_e1[[2]])))
      # else unary `+` should just return it's input
      } else e1
    # if binary `+`, keep original behavior
    } else .Primitive("+")(e1,e2)
}

x <- 10
++x
x
# [1] 11

अन्य ऑपरेशन नहीं बदलते हैं:

x + 2
# [1] 13
x ++ 2
# [1] 13
+x
# [1] 11
x
# [1] 11

हालांकि यह मत करो क्योंकि आप सब कुछ धीमा कर देंगे। या इसे किसी अन्य वातावरण में करें और सुनिश्चित करें कि आपके पास इन निर्देशों पर बड़े लूप नहीं हैं।

आप यह भी कर सकते हैं:

`++` <- function(x) eval.parent(substitute(x <-x +1))
a <- 1
`++`(a)
a
# [1] 2

Answer 8

ऐसा करने का एक और तरीका है, जो मुझे बहुत आसान लगता है, शायद कुछ मदद हो सकती है

मैं <<-इन परिस्थितियों के लिए उपयोग करता हूं । ऑपरेटर <<-मूल वातावरण के लिए मान प्रदान करते हैं

inc <- function(x)
{
   x <<- x + 1
}

और आप इसे पसंद कर सकते हैं

x <- 0
inc(x)