आप दो बार सही तरीके से कैसे लिखते हैं for आर में लूप?
उदाहरण के लिए, सी में मैं करूँगा
int i, j;
for (i = 1; i < 6; i++) {
for (j=i; j <= 3; j++) {
printf("%i,%in",i,j);
}
// Do more operations for i > 3...
}
जो (कृत्रिम) अनुक्रम उत्पन्न करेगा:
1,1
1,2
1,3
2,2
2,3
3,3
जब आप लिखते हैं तो आपको वही व्यवहार नहीं मिलता है
for (i in 1:6) {
for (j in i:3) {
print(paste(i,j,sep=","))
}
}
तो मुझे कुछ ऐसा करने के लिए कम कर दिया गया है
for (i in 1:6) {
j <- i
while (j <= 3) {
print(paste(i,j,sep=","))
j <- j+1
}
}
क्या कोई बेहतर तरीका है?
जैसे शेन ने उल्लेख किया, शायद मुझे यह बनाना चाहिएस्पष्ट: छात्रों को समझने में आसान बनाने के लिए गणित से मेल खाने वाली कोड-शैली में विशेष रूप से दिलचस्पी है। ऐसा लगता है कि छात्र सबसे सहज हैं for लूप।
विशेष रूप से, मैं चाहता हूं कि मेरे छात्र एक अनुकरण करें LIBOR बाजार मॉडल। आगे की दर की गतिशीलता होनी चाहिएएक ही संभावना माप के तहत नकली। इस तरह, हर बार कदम और प्रत्येक के लिए आगे की दर, उपयुक्त बहाव सुधार mu_i की गणना और जोड़ा जाना चाहिए।
उत्तर:
उत्तर № 1 के लिए 11यह पूछने के लिए खेद है कि संभावित रूप से एक गूंगा सवाल क्या है, लेकिन किस अर्थ में आर ऐसा नहीं कर सकता है? यह मेरे लिए बिल्कुल ठीक काम करता है:
N <- 5
for (i in 0:(2*N)) {
for (j in i:N) {
print(paste(i,j,sep=","))
}
}
क्या यह हो सकता है कि आपने अभी तक अपने अनुक्रम के अंत में कोष्ठक नहीं लगाए?
संपादित करें: समझा...आप यह लागू करना चाहते हैं कि अनुक्रम I: 3 हमेशा <= 3 है? मुझे लगता है कि "या तो अनुक्रम के साथ या बयान के खंड के भीतर संभव नहीं है। आप लूप के भीतर एक ब्रेक सेट कर सकते हैं, लेकिन यह आपके वर्तमान दृष्टिकोण से बेहतर नहीं है:
for (i in 1:6) {
for (j in i:3) {
if(j > 3) break()
print(paste(i,j,sep=","))
}
}
यहां लूप के बिना इस अनुक्रम को उत्पन्न करने का एक और तरीका है:
x <- cbind(rep(c(1,2,3), 3),
rep(c(1,2,3), each=3))
या expand.grid के साथ (Dirk के सुझाव के अनुसार):
x <- expand.grid(x=1:3, y=1:3)
फिर अवांछित मामलों को हटा दें:
x[x[,1] >= x[,2],]
2 संपादित करें: यह आपकी आवश्यकताओं के अनुरूप नहीं हो सकता है, लेकिन मेरा मानना है कि क्वांटलिब में लिबर मार्केट मॉडल कार्यान्वयन है। मुझे यकीन नहीं है कि यह है या नहीं RQuantlib में उजागर.
जवाब के लिए 9 № 2
आप निश्चित रूप से घोंसला loops कर सकते हैं:
R> for (i in 1:3) for (j in 1:3) cat(i,j,i*j, "n")
1 1 1
1 2 2
1 3 3
2 1 2
2 2 4
2 3 6
3 1 3
3 2 6
3 3 9
R>
सामान्य ज्ञान है कि आप नहीं चाहिए क्योंकि वेक्टरिज्ड कॉल पढ़ने और लिखना आसान हो सकता है:
R> outer(1:3,1:3, "*")
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 2 4 6
[3,] 3 6 9
R>
लेकिन अगर अगली लूप के साथ विकसित करना आसान है, तो ऐसा करें।
"पहली अनुक्रमणिका पर निर्भर दूसरी सूचकांक" मुद्दे के लिए आप इसे प्राप्त करने के लिए low.tri (), upper.tri () या अनुक्रमण का उपयोग कर सकते हैं।
R> X <- expand.grid(x=1:3, y=1:3)
R> X <- X[ X$x >= X$y, ]
R> outer(X$x, X$y, "*")
[,1] [,2] [,3] [,4] [,5] [,6]
[1,] 1 1 1 2 2 3
[2,] 2 2 2 4 4 6
[3,] 3 3 3 6 6 9
[4,] 2 2 2 4 4 6
[5,] 3 3 3 6 6 9
[6,] 3 3 3 6 6 9
R>
जवाब के लिए 5 № 3
यहां मुद्दा यह है कि i:3 जब सार्थक है i>3। उदाहरण के लिए, 5:3 देता है (5,4,3)। दूसरी लूप को चलाने के लिए आपको केवल इतना ही जरूरी है कि कथन i>3.
for (i in 1:6) {
if(i < 4) {
for (j in i:3) {
print(paste(i,j,sep=","))
}
}
# Do more operations for i > 3...
}
हालांकि, यदि संभव हो तो स्पष्ट लूपिंग से बचने का प्रयास करें। Dirk "और शेन के जवाब इस बारे में कुछ विचार प्रदान करते हैं कि यह कैसे करें।