Miesiąc: wrzesień 2020

Funkcja switch() przyjmuje dowolną liczbę argumentów. Pierwszy argument mówi switch (), który z poniższych argumentów ma zwrócić. Argumenty występujące po pierwszym argumencie to zwracane obiekty. Pierwszy argument musi być numeryczny, logiczny, złożony, znakowy lub NA i musi składać się z pojedynczego elementu. Reszta argumentów może mieć dowolny tryb i wymiar. Przecinki oddzielają argumenty. Jeśli pierwszy argument jest liczbowy, liczba jest zaokrąglana w dół do liczby całkowitej; jeśli jest to logiczne, TRUE jest wymuszane na 1, a FALSE na 0; a jeśli jest złożony, część urojoną jest odrzucana, a część rzeczywista jest traktowana jak numeryczna. Funkcja zwraca argument wskazany przez pierwszy argument. Na przykład, jeśli pierwszy argument to 3, to zwracany jest czwarty argument. To jest:

> switch(3,5,”a”,”b”,6)

[1] “b”

Jeśli pierwszy argument jest większy niż liczba argumentów minus jeden, jest mniejszy niż jeden lub ma wartość NA, to zwracany jest obiekt NULL. Na przykład:

> switch(0,1,2,3)

> mode(switch(0,1,2,3))

[1] “NULL”

Ciąg znaków dla pierwszego elementu powoduje, że funkcja switch () zachowuje się inaczej. Funkcja sprawdza nazwy argumentów występujących po ciągu znaków, aby spróbować znaleźć dopasowanie. Wszystkie poniższe argumenty muszą zostać nazwane z wyjątkiem jednego możliwego elementu bez nazwy. (Argumenty można nazwać na liście, wprowadzając nazwę, po której następuje znak równości, po którym następuje – opcjonalna – wartość.) Jeśli istnieje argument bez nazwy, wówczas ten argument staje się wartością domyślną, jeśli nie ma dopasowania do ciąg znaków. Jeśli nie ma argumentu bez nazwy, wartością domyślną jest obiekt NULL. Na przykład:

> switch(“e”, a=1, b=2, c=3, d=4, e=f.fun(0))

[1] 1.959964

> switch(“e”, a=1, b=2, c=3, d=4, 25)

[1] 25

> switch(“e”, a=1, b=2, c=3, d=4)

> mode(switch(“e”, a=1, b=2, c=3, d=4))

[1] “NULL”

Nienazwany argument może pojawić się w dowolnym miejscu listy oprócz pierwszego argumentu. Jeśli wprowadzono więcej niż jeden nienazwany argument, funkcja switch () zwraca błąd. Dzięki ciągowi znaków dla pierwszego argumentu, kolejnym argumentom nie trzeba przypisywać wartości, a jedynie nazwę. Jeśli ciąg znaków pasuje do nazwy bez wartości, to funkcja switch () kontynuuje wyświetlanie listy argumentów i zwraca wartość następnego argumentu z wartością. Jeśli żaden z kolejnych argumentów nie zawiera wartości, przełącznik zwraca obiekt NULL. Na przykład:

> switch(“b”, a=1,b=2,c=,d=,e=5)

[1] 2

> switch(“b”, a=1, b=, c=3, d=)

[1] 3

> switch(“b”, a=1, b=, c=, d=)

> mode(switch(“b”, a=1, b=, c=, d=))

[1] “NULL”

Zauważ, że pierwszy argument jest ujęty w cudzysłów, podczas gdy nazwy kolejnych argumentów nie. Funkcja switch () może być zagnieżdżona. Więcej informacji na temat funkcji switch () można znaleźć, wpisując? Switch w wierszu polecenia R

Funkcja ifelse() przyjmuje trzy argumenty. Pierwszym jest obiekt logiczny lub dowolny obiekt, który można przekształcić w logikę, taki jak obiekty modów atomowych lub obiekty z listy trybów, w których lista ma tylko jeden poziom głębi i każdy element przyjmuje tylko jedną wartość. Można również użyć funkcji zwracającej wartości, które można przekształcić w wartości logiczne. Drugi argument to wartości, które mają zostać zwrócone, gdy pierwszy argument jest prawdziwy. Trzeci argument to wartości, które mają zostać zwrócone, gdy pierwszy argument jest fałszywy. Każdy element pierwszego argumentu jest testowany osobno. Elementy postaci trybu i brakujące elementy zwracają NA. W przeciwnym razie zwracana wartość dla danego elementu to wartość na tej samej pozycji w drugim (lub trzecim) argumencie. Na przykład, jeśli pierwszym argumentem jest wektor (T, T, F, T), drugim argumentem jest wektor (1,2,1,2), a trzecim argumentem (4,5,6,4) , to ifelse () zwraca (1,2,6,2). To jest:

> ifelse (c (T, T, F, T), c (1: 2,1: 2), c (4: 6,4))

[1] 1 2 6 2

Jeśli to możliwe, wynik ma takie same wymiary jak pierwszy argument. W przeciwnym razie zwracany jest wektor listy trybów o długości równej długości pierwszego argumentu. Na przykład:

> a.mat = matrix(0:3,2,2)

> a.mat

[,1] [,2]

[1,] 0 2

[2,] 1 3

> a.list = list(a.mat,c(“a”,”b”,”c”))

> a.list

[[1]]

[,1] [,2]

[1,] 0 2

[2,] 1 3

[[2]]

[1] “a” “b” “c”

> ifelse(a.mat,1:4,30:33)

[,1] [,2]

[1,] 30 3

[2,] 2 4

> ifelse(a.mat,1:4,a.list)

[[1]]

[,1] [,2]

[1,] 0 2

[2,] 1 3

[[2]]

[1] 2

[[3]]

[1] 3

[[4]]

[1] 4

Zauważ, że w drugim wywołaniu ifelse () pierwszy element a.mat daje FALSE, a pierwszy element a.list to macierz, więc lista jest generowana. Jeśli długość pierwszego argumentu jest mniejsza niż długość drugiego (lub trzeciego) argumentu, zostaną użyte tylko te elementy w drugim (lub trzecim) argumencie do długości pierwszego argumentu. Na przykład:

> ifelse (c (T, F), 1: 5, 10:15)

[1] 1 11

Pierwszy element 1: 5 to 1, a drugi element 10:15 to 11, więc zwracane jest (1,11). Jeśli długość pierwszego argumentu jest większa niż długość drugiego (lub trzeciego) argumentu, drugi (lub trzeci) argument jest cykliczny. Na przykład:

> ifelse (c (T, F, F, F, T), 1: 3, 10:12)

[1] 1 11 12 10 2

Drugi argument przechodzi do (1,2,3,1,2), a trzeci argument przechodzi do (10,11,12,10,11). Jeśli tryby elementów wynikowych nie są takie same, wynik będzie miał tryb elementu o najwyższej hierarchii, w którym hierarchia przechodzi od najniższej do najwyższej logicznej, całkowitej, podwójnej, zespolonej, znakowej i listowej. Obiekty trybu NULL i raw powodują błąd. Na przykład:

> ifelse (c (T, F, F, F, T), 1: 5 + 1i, 1: 5)

[1] 1 + 1i 2 + 0i 3 + 0i 4 + 0i 5 + 1i

> ifelse (c (T, F, F, F, T), as.raw (2: 6), as.raw (12:16))

Error in ifelse(c(T, F, F, F, T), as.raw(2:6), as.raw(12:16)) :

incompatible types (from raw to logical) in subassignment type fix

Funkcji można użyć jako wartości dowolnego z trzech argumentów. Jeśli funkcja jest oceniana, wynik funkcji jest zwracany jako pierwszy. Ostatni wynik jest wynikiem zamiany. Na przykład:

> f.fun = function(mu, se=1, alpha=.05){

q_value = qnorm(1-alpha/2, mu, se)

print(q_value)

}

> ifelse (f.fun(1:2, alpha=1.0), f.fun(1:2), f.fun(3))

[1] 1 2

[1] 2.959964 3.959964

[1] 2.959964 3.959964

> ifelse (f.fun(0:2, alpha=1.0), f.fun(1:2), f.fun(3))

[1] 0 1 2

[1] 2.959964 3.959964

[1] 4.959964

[1] 4.959964 3.959964 2.959964

Zauważ, że w pierwszym wywołaniu f.fun(), alpha jest ustawiana na 1.0, więc zwracana jest mediana. Ponadto w pierwszym wywołaniu oceniane są dwie pierwsze funkcje, podczas gdy w drugim wywołaniu oceniane są wszystkie trzy funkcje. Jeśli wynik jest przypisany do obiektu, to wyniki funkcji są wypisywane na konsoli, ale wynik ifelse() jest przekazywany do obiektu. Na przykład:

> a=ifelse (f.fun(1:2, alpha=1.0), f.fun(1:2), f.fun(3))

[1] 1 2

[1] 2.959964 3.959964

> a

[1] 2.959964 3.959964

Funkcja ifelse () może być zagnieżdżona. Na przykład łańcuch Markowa pierwszego rzędu o długości sześć z dwoma stanami, w których znajduje się macierz przejścia

można wygenerować za pomocą zagnieżdżonych funkcji ifelse (). Oznacza to, że „A” będzie pierwszym stanem, a „B” drugim stanem:

> set.seed(6978)

> mc=”A”

> for (i in 2:6) {

+ rn = runif(1)

+ mc = c(mc, ifelse(mc[i-1]==”A”, ifelse(rn<=0.7,”A”,”B”),

ifelse(rn<=0.8,”B”,”A”)))

+ }

> mc

[1] “A” “A” “B” “B” “B” “B”

Więcej informacji o ifelse() można znaleźć, wpisując ?ifelse po znaku zachęty R.

W tym przykładzie losowe próbki o rozmiarze 100 standardowych liczb normalnych są generowane w pętli powtarzania, która znajduje się w pętli for, która przechodzi przez 10 000 iteracji. Dla każdej próbki sumę próbki dzieli się przez pierwiastek kwadratowy z 100, a następnie porównuje z 1,965. Jeśli wartość jest mniejsza niż 1,965, pętla powtarzania jest kontynuowana.

W przeciwnym razie pętla powtarzania zatrzymuje się, rejestrowana jest liczba powtórzeń pętli i rozpoczyna się następna pętla for. Na końcu wektor liczb przechodzących przez pętlę jest wykreślany na histogramie i znajduje średnią i medianę liczby razy. Najpierw ustawiane jest ziarno dla generatora liczb losowych. Wtedy jest wektor n.hist utworzony do przechowywania wyników, z miejscem na każdą iterację pętli for. Następnie otwiera się pętla for i licznik n jest ustawiany na zero. Następnie otwiera się pętla powtarzania. Na początku pętli powtarzania licznik n jest zwiększany o jeden. Następnie pobierana jest próbka, dzielona przez dziesięć, a wynik jest równy x. Następnie wartość x jest porównywana z 1,965 w instrukcji if. Jeśli wartość jest większa niż 1,965, to n.hist dla indeksu i jest równe licznikowi n, a instrukcja break przerywa funkcję z pętli powtarzania. W przeciwnym razie pętla powtarzania będzie kontynuowana w pętli. Na końcu uruchamiana jest funkcja hist () w celu utworzenia histogramu n.hist, średnia () w celu znalezienia średniej z n.hist, a metoda mediana () w celu znalezienia mediany z n.hist. Oto przykład:

> set.seed(69785)

> n.hist = numeric(10000)

> for (i in 1:10000) {

+ n=0

+ repeat{

+ n=n+1

+ x=sum(rnorm(100)/10)

+ if (x>1.965) {n.hist[i]=n; break}

+ }

+ }

> hist(n.hist)

> mean(n.hist)

[1] 40.4769

> median(n.hist)

[1] 28

Należy zauważyć, że średnia jest bliska 40, co jest przewidywaną średnią liczbą prób niezbędnych do zobaczenia zdarzenia z prawdopodobieństwem wystąpienia 0,025. Jednak mediana jest znacznie mniejsza, ponieważ rozkład jest mocno wypaczony.

Korzystanie z indeksów

Aby wykonać ten przykład przy użyciu indeksów, stwierdziliśmy, że pętla powtarzania jest konieczna, ale można zrezygnować z pętli for. Ponownie, ziarno generatora liczb losowych jest ustawione na tę samą liczbę, co w pierwszej części przykładu, a n.hist jest zdefiniowane numerycznie z 10000 elementów. Następnie licznik n jest ustawiany na zero, licznik cl.sv jest ustawiany na zero, a licznik n.col jest ustawiany na 10000. Następnie otwiera się pętla powtarzania. Macierz x jest zdefiniowana jako macierz składająca się ze 100 wierszy i n.col kolumn (początkowo 10 000). Elementy x to 100 razy n.col losowo generowane standardowe liczby normalne. Następnie funkcja apply () jest używana do zsumowania każdej kolumny macierzy, a wynik jest przypisywany do x. Następnie każdy element x jest dzielony przez 10. Następnie długość wektora zawierającego te elementy x, które są większe niż 1,965, jest przypisywana do x. Następnie x jest dodawane do cl.sv, a n jest zwiększane o jeden. Następnie wartości n.hist są równe n, gdzie cl.sv i x są używane do określenia, gdzie wzdłuż wektora n.hist należy umieścić wartość n. Następnie n.col jest zmniejszane o wartość x. Pętla powtarzania trwa do momentu, gdy n.col będzie równe zero. Histogram n.hist jest generowany za pomocą funkcji hist (), średnią z n.hist za pomocą średniej (), a medianę n.hist za pomocą mediany (). Oto przykład:

> set.seed(69785)

> n.hist = numeric(10000)

> n = 0

> cl.sv = 0

> n.col = 10000

> repeat{

+ x = matrix(rnorm(n.col*100), 100, n.col)

+ x = apply(x, 2, sum)

+ x = x/10

+ x = length(x[x>1.965])

+ cl.sv = cl.sv + x

+ n = n+1

+ n.hist[(cl.sv-x+1):cl.sv] = n

+ n.col = n.col-x

+ if (n.col==0) break

+ }

> hist(n.hist)

> mean(n.hist)

[1] 40.5015

> median(n.hist)

[1] 28

Ponownie średnia jest bliska 40, a mediana 28. Obie metody wykorzystują mniej więcej taki sam czas. Jeśli wartość 10 000 zostanie zastąpiona powyżej 100 000, metoda zapętlenia zajmie około 53 sekund, a metoda indeksowania około 56 sekund na moim komputerze. Ponieważ proces generowania próbek losowych jest inny dla obu metod – druga metoda generuje więcej liczb niż pierwsza – wyniki dla dwóch metod nie są identyczne, mimo że materiał początkowy generatora liczb losowych jest taki sam

W tym przykładzie generowane są standardowe normalne liczby losowe i porównywane z 1,965. Zachowywane są tylko te wartości, które są mniejsze lub równe 1,965. Najpierw ziarno generatora liczb losowych jest ustawiane na dowolną wartość. Następnie generowana jest pojedyncza standardowa liczba normalna. (Pomijamy możliwość, że liczba jest większa niż 1,965). W następnej pętli for, dla 10 000 iteracji, w każdej iteracji generowana jest standardowa normalna liczba losowa. Jeśli liczba jest większa niż 1,965, rozpoczyna się następna pętla. W przeciwnym razie liczba jest dodawana do wektora liczb. Przedstawiony jest histogram końcowego wektora. Oto przykład:

> set.seed(69785)

> 

> x = rnorm(1)

> 

> for (i in 1:10000) {

+ x2 = rnorm(1)

+ if (x2>1.965) next

+ x = c(x, x2)

+ }

> 

> hist(x)

Korzystanie z indeksów

Korzystanie z indeksów jest znacznie prostsze. Po pierwsze, ziarno generatora liczb losowych jest ustawiane na taką samą wartość, jak w poprzednim przykładzie. Następnie generowany jest wektor standardowych normalnych zmiennych losowych o długości 10 001. Następnie zachowywane są tylko te wartości w wektorze, które są mniejsze lub równe 1,965. Na koniec generowany jest histogram wektora. Oto przykład:

> set.seed (69785)

> 

> x = rnorm (10001)

> x = x [x <= 1,965]

> 

> hist (x)

Zauważ, że te dwa histogramy są takie same, ponieważ nasiona są takie same i używane są te same 1001 liczb. Jeśli wartość 10 000 zostanie zwiększona do powyżej 100 000, na moim komputerze metoda wykorzystująca pętle zajmuje około 13 sekund, podczas gdy metoda wykorzystująca indeksy zajmuje mniej niż 1 sekundę

Czasami potrzebne są różnice między każdą z kolumn macierzy. W tym przykładzie zagnieżdżone pętle for są używane do znajdowania różnic. Najpierw generowana jest macierz x z dwoma wierszami i czterema kolumnami, do której są przypisywane nazwy kolumn. Następnie wyświetlana jest macierz. Następnie generowana jest macierz xp zer z dwoma wierszami i sześcioma kolumnami w celu przechowywania wyników różnic, a macierzy przypisywane są puste nazwy kolumn. Następnie licznik k dla kolumn macierzy xp jest ustawiany na zero. Wraz ze wzrostem liczby pętli for, k będzie wzrastać o jeden na każdym kroku. Następnie uruchamiane są dwie pętle for. W pętlach elementy xp są wypełnione różnicami między różnymi kolumnami w x. Dwie pętle przechodzą w pętli przez kolumny macierzy x w taki sposób, że żadne kombinacje kolumn nie są powtarzane, a dwie kolumny nigdy nie są takie same. Na każdym kroku kolumny xp mają przypisane nazwy na podstawie nazw w x. Na koniec wyświetlana jest wynikowa macierz xp. Oto przykład:

> x = matrix(1:8,2,4)

> colnames(x) = paste(“c”, 1:4, sep=””)

> x

c1 c2 c3 c4

[1,] 1 3 5 7

[2,] 2 4 6 8

> xp = matrix(0,2,6)

> colnames(xp) = rep(“”,6)

> xp

[1,] 0 0 0 0 0 0

[2,] 0 0 0 0 0 0

> k=0

> for (i in 1:3) {

+ for (j in (i+1):4) {

+ k = k+1

+ xp[,k] = x[,i]-x[,j]

+ colnames(xp)[k] = paste(colnames(x)[i], “-“, colnames(x)[j], sep=””)

+ }

+ }

> 

> xp

c1-c2 c1-c3 c1-c4 c2-c3 c2-c4 c3-c4

[1,] -2 -4 -6 -2 -4 -2

[2,] -2 -4 -6 -2 -4 -2

Zauważ, że liczba kolumn w xp jest równa p (p-1) / 2, gdzie p jest liczbą kolumn w x.

Korzystanie z indeksów

Aby rozwiązać ten problem za pomocą indeksów, tworzone są dwa wektory indeksów. Najpierw generowana jest początkowa macierz x, przypisywane nazwy kolumn i wyświetlane. Następnie tworzone są dwa zbiory indeksów o tej samej długości, indeks 1 i indeks 2. Odpowiednie indeksy w obu zestawach nigdy nie są takie same, a wszystkie możliwe kombinacje są obecne i występują tylko raz. Następnie otrzymana macierz xp jest tworzona przez odjęcie kolumn x w drugim zestawie indeksów od kolumn x w pierwszym zestawie indeksów. Następnie nazwy kolumn dla xp są tworzone i przypisywane za pomocą metody paste () i dwóch zestawów indeksów. Na koniec wyświetlana jest macierz xp. Oto przykład:

> x = matrix(1:8,2,4)

> colnames(x) = paste(“c”, 1:4, sep=””)

> x

c1 c2 c3 c4

[1,] 1 3 5 7

[2,] 2 4 6 8

> ind.1 = rep(1:3,3:1)

> ind.1

[1] 1 1 1 2 2 3

> ind.2 = 2:4

> for(i in 3:4) ind.2 = c(ind.2,i:4)

> ind.2

[1] 2 3 4 3 4 4

> xp = x[,ind.1] – x[,ind.2]

> colnames(xp) = paste(“c”, ind.1, “-“,”c”, ind.2, sep=””)

> xp

c1-c2 c1-c3 c1-c4 c2-c3 c2-c4 c3-c4

[1,] -2 -4 -6 -2 -4 -2

[2,] -2 -4 -6 -2 -4 -2

Zauważ, że pętla for służy do tworzenia drugiego zestawu indeksów. Ponadto indeksy kolumn są powtarzane w obu zestawach indeksów. W przypadku dużych macierzy druga metoda jest szybsza niż pierwsza. Na moim komputerze różnice kolumn dla dwóch macierzy, z których każda zawierała 43 830 wierszy i 35 kolumn, zostały znalezione za pomocą dwóch metod. Obie metody dały tę samą macierz 43 830 na 595. Metoda zapętlania zajęła około 1,5 sekundy, a metoda indeksowania około 1,0 sekundy

W tym przykładzie pętla while służy do określenia, ile iteracji potrzeba, aby suma zmiennych rozłożonych losowo i równomiernie między zerem a jedynką była większa niż pięć. Po początkowym ustawieniu ziarna dla generatora liczb losowych i ustawieniu n i x na zero, rozpoczyna się pętla while w celu zwiększenia n i sumowania x. Liczba wygenerowana za pomocą generatora liczb losowych dla rozkładu równomiernego jest dodawana do x przy każdej iteracji. Gdy x jest większe niż pięć, zapętlenie zatrzymuje się. Wartości n i x są drukowane. Oto przykład:

> set.seed(129435)

> n=0

> x=0

> while (x<=5) {

+ x = x + runif(1)

+ n = n + 1

+ }

> n

[1] 7

> x

[1] 5.179325

Korzystanie z indeksów

Aby wykonać to samo zadanie za pomocą indeksów, generowany jest wektor jednolitych zmiennych losowych o długości większej niż oczekiwana dla wyniku sumy. Następnie funkcja cumsum (), która tworzy sumę skumulowaną wzdłuż wektora, jest używana do określenia, kiedy suma jest większa niż pięć. Ponieważ elementy x są zawsze większe od zera, skumulowana suma zawsze rośnie wzdłuż wektora. Następnie funkcja length () służy do znalezienia liczby elementów, dla których suma jest mniejsza lub równa pięć. Następnie drukowane są wartości n i x, gdzie x jest równe x [n].

> set.seed(129435)

> x = runif(25)

> x = cumsum(x)

> n = length(x[x<=5])+1

> x = x[n]

> n

[1] 7

> x

[1] 5.179325

Zauważ, że generator liczb losowych jest ustawiony na tę samą wartość początkową dla obu części przykładu, więc wyniki dla dwóch pasujących wyników, ponieważ generowane są te same pierwsze siedem liczb. Jeśli na moim komputerze podstawię 1 000 000 na 5 w powyższych przykładach i 3 000 000 na 25, metoda wykorzystująca indeksy jest prawie natychmiastowa, podczas gdy metoda wykorzystująca zapętlenie zajmuje około 9 sekund

W tym przykładzie wykonujemy podstawianie element po elemencie do macierzy na podstawie testu if / else. Najpierw generowana jest macierz x dwa na pięć i wyświetlana jest macierz. Następnie dwie pętle for przechodzą przez indeksy wierszy i kolumn x. W każdym cyklu zestaw instrukcji if / else sprawdza, czy element macierzy jest większy niż pięć. Jeśli wartość elementu jest większa niż pięć, wartość elementu jest zastępowana jedynką. Jeśli nie, kontrola przechodzi do instrukcji else. W instrukcji else wartość elementu jest zastępowana przez zero. Na koniec wyświetlana jest wynikowa macierz. Oto przykład:

> x = matrix(1:10,2,5)

> x

[,1] [,2] [,3] [,4] [,5]

[1,] 1 3 5 7 9

[2,] 2 4 6 8 10

> for (i in 1:2) {

+ for (j in 1:5) {

+ if ( x[i,j]>5 ) x[i,j]=1

+ else x[i,j]=0

+ }

+ }

> x

[,1] [,2] [,3] [,4] [,5]

[1,] 0 0 0 1 1

[2,] 0 0 1 1 1

Korzystanie z indeksów

Wykonanie tej samej zamiany bez pętli jest łatwiejsze. Najpierw generowana i wyświetlana jest macierz x. Następnie druga macierz, y, jest równa x. Macierz y służy do przechowywania wartości x, ponieważ wartości x zmieniane są w dwóch krokach. Następnie elementy w x są ustawiane jako równe nowym wartościom na podstawie oryginalnych wartości, które są w y. Ostatni wynik wyświetlony jest matryca. Oto przykład:

> x = matrix(1:10,2,5)

> x

[,1] [,2] [,3] [,4] [,5]

[1,] 1 3 5 7 9

[2,] 2 4 6 8 10

> y=x

> x[y>5] = 1

> x[y<=5] = 0

> x

[,1] [,2] [,3] [,4] [,5]

[1,] 0 0 0 1 1

[2,] 0 0 1 1 1

Na moim komputerze, przy użyciu macierzy z 43 830 wierszami i 35 kolumnami, metoda zapętlania zajęła około pięciu sekund, a metoda indeksowania mniej niż sekundę

Instrukcja kontroli przepływu repeat powtarza sekcję kodu, aż do osiągnięcia punktu zatrzymania. Punkt zatrzymania musi być zaprogramowany w sekcji kodu. W przeciwieństwie do while, repeat nie ma obiektu logicznego jako części instrukcji sterującej iw przeciwieństwie do for, żaden indeks pętli nie jest częścią instrukcji sterującej. Poniżej znajdują się dwie formy do powtórzenia:

repeat {‘some code statements separated by semicolons’}

repeat {

‘lines of code statements’

}

Ponownie, te dwie kwestie nie są wyczerpujące. Nieskończone pętle są możliwe z powtórzeniami, więc zachowaj ostrożność.

Instrukcje „break” i „next”

Instrukcje break i next służą do sterowania przepływem w tych sekcjach kodu kontrolowanych przez jeden z kontrolerów przepływu. Instrukcja break mówi R, aby zostawił pętlę for, while, repeat lub sekcję if i przeszedł do pierwszej instrukcji po pętli lub sekcji. Instrukcja next mówi R, aby przestał wykonywać instrukcje kodu w pętli for, while, lub powtórzył pętlę i zaczął ponownie od początku pętli – z wartością zmiennej indeksującej, jeśli istnieje, przyjmując następną wartość zmiennej zmienna.

Zagnieżdżanie

Każda instrukcja kontroli przepływu może być zagnieżdżona w innych sekcjach kodu kontroli przepływu. Ze względu na przejrzystość i zapobieganie subtelnym błędom podczas zagnieżdżania sekcji sterowania przepływem w innych sekcjach sterowania należy używać nawiasów na wszystkich poziomach. Większość informacji przedstawionych tutaj na temat sterowania przepływem pochodzi ze strony pomocy CRAN dotyczącej sterowania przepływem, którą można znaleźć, wpisując? „If” w wierszu zachęty R