Comprensione della funzione order ()

Sto cercando di capire come funziona la funzione order() . Avevo l’impressione che restituisse una permutazione degli indici, che, una volta ordinati, ordinava il vettore originale.

Per esempio,

 > a  order(a) [1] 3 1 2 4 

Mi sarei aspettato che questo restituisse c(2, 3, 1, 4) , poiché la lista ordinata sarebbe 10 45 50 96.

Qualcuno può aiutarmi a capire il valore di ritorno di questa funzione?

Questo sembra spiegarlo.

La definizione di order è che a[order(a)] è in ordine crescente. Funziona con il tuo esempio, in cui l’ordine corretto è il quarto, il secondo, il primo e il terzo elemento.

Potresti aver cercato il rank , che restituisce il rango degli elementi
R> a < - c(4.1, 3.2, 6.1, 3.1)
R> order(a)
[1] 4 2 1 3
R> rank(a)
[1] 3 2 4 1
così il rank ti dice in che ordine sono i numeri, l' order ti dice come ottenerli in ordine crescente.

plot(a, rank(a)/length(a)) darà un grafico del CDF. Per capire perché l' order è utile, prova la plot(a, rank(a)/length(a),type="S") che dà un casino, perché i dati non sono in ordine crescente

Se avete fatto
oo< -order(a)
plot(a[oo],rank(a[oo])/length(a),type="S")
o semplicemente
oo< -order(a)
plot(a[oo],(1:length(a))/length(a)),type="S")
ottieni un grafico a linee del CDF.

Scommetto che stai pensando al grado.

Per ordinare un vettore 1D o una singola colonna di dati, basta chiamare la funzione di ordinamento e passare la sequenza.

D’altra parte, la funzione di ordine è necessaria per ordinare i dati bidimensionali – cioè più colonne di dati raccolti in una matrice o in un dataframe.

 Stadium Home Week Qtr Away Off Def Result Kicker Dist 751 Out PHI 14 4 NYG PHI NYG Good D.Akers 50 491 Out KC 9 1 OAK OAK KC Good S.Janikowski 32 702 Out OAK 15 4 CLE CLE OAK Good P.Dawson 37 571 Out NE 1 2 OAK OAK NE Missed S.Janikowski 43 654 Out NYG 11 2 PHI NYG PHI Good J.Feely 26 307 Out DEN 14 2 BAL DEN BAL Good J.Elam 48 492 Out KC 13 3 DEN KC DEN Good L.Tynes 34 691 Out NYJ 17 3 BUF NYJ BUF Good M.Nugent 25 164 Out CHI 13 2 GB CHI GB Good R.Gould 25 80 Out BAL 1 2 IND IND BAL Good M.Vanderjagt 20 

Ecco un estratto di dati per i tentativi di field goal nella stagione NFL 2008, un dataframe che ho chiamato ‘fg’. supponiamo che questi 10 punti di dati rappresentino tutti gli obiettivi sul campo tentati nel 2008; Supponiamo inoltre di voler conoscere la distanza dell’objective da campo più lungo tentato quell’anno, chi lo ha calciato e se è stato buono o meno; vuoi anche conoscere la seconda più lunga, così come la terza più lunga, ecc .; e infine vuoi il tentativo di field goal più corto.

Bene, puoi semplicemente fare questo:

 sort(fg$Dist, decreasing=T) 

che restituisce: 50 48 43 37 34 32 26 25 25 20

Questo è corretto, ma non molto utile: ci dice la distanza del più lungo tentativo di field goal, il secondo più lungo, … e il più breve; tuttavia, questo è tutto ciò che sappiamo – ad esempio, non sappiamo chi fosse il kicker, se il tentativo ha avuto successo, ecc. Naturalmente, abbiamo bisogno dell’intero dataframe ordinato sulla colonna “Dist” (in altre parole, vuoi ordinare tutte le righe di dati sul singolo attributo Dist . che sarebbe simile a questo:

 Stadium Home Week Qtr Away Off Def Result Kicker Dist 751 Out PHI 14 4 NYG PHI NYG Good D.Akers 50 307 Out DEN 14 2 BAL DEN BAL Good J.Elam 48 571 Out NE 1 2 OAK OAK NE Missed S.Janikowski 43 702 Out OAK 15 4 CLE CLE OAK Good P.Dawson 37 492 Out KC 13 3 DEN KC DEN Good L.Tynes 34 491 Out KC 9 1 OAK OAK KC Good S.Janikowski 32 654 Out NYG 11 2 PHI NYG PHI Good J.Feely 26 691 Out NYJ 17 3 BUF NYJ BUF Good M.Nugent 25 164 Out CHI 13 2 GB CHI GB Good R.Gould 25 80 Out BAL 1 2 IND IND BAL Good M.Vanderjagt 20 

Questo è l’ ordine . È “ordinata” per dati bidimensionali; in un altro modo, restituisce un indice intero 1D composto da numeri di riga tali che ordinando le righe in base a quel vettore, ti darebbe un ordinamento orientato alla riga corretto sulla colonna, Dist

Ecco come funziona. Sopra, ordinamento è stato usato per ordinare la colonna Dist; per ordinare l’intero dataframe sulla colonna Dist, usiamo ‘ordine’ esattamente nello stesso modo in cui ‘ordina’ è usato sopra :

 ndx = order(fg$Dist, decreasing=T) 

(Di solito lego la matrice restituita da “ordine” alla variabile “ndx”, che sta per “indice”, perché sto andando a usarlo come matrice di indici per ordinare.)

quello era il passaggio 1, ecco il passaggio 2:

‘ndx’, ciò che viene restituito da ‘sort’ viene quindi utilizzato come array di indici per riordinare il dataframe, ‘fg’:

 fg_sorted = fg[ndx,] 

fg_sorted è il dataframe riordinato immediatamente sopra.

In sintesi, ‘ordina’ viene utilizzato per creare una matrice di indici (che specifica l’ordinamento della colonna che si desidera ordinare), che viene quindi utilizzata come matrice di indici per riordinare il dataframe (o matrice).

(Ho pensato che potrebbe essere utile delineare le idee molto semplicemente qui per riassumere il buon materiale pubblicato da @doug, e collegato da @duffymo; +1 a ciascuno, btw.)

? order ti dice quale elemento del vettore originale deve essere messo prima, secondo, ecc., in modo da ordinare il vettore originale, mentre ? rank ti dice quale elemento ha il valore più basso, il secondo più basso, ecc. Per esempio:

 > a < - c(45, 50, 10, 96) > order(a) [1] 3 1 2 4 > rank(a) [1] 2 3 1 4 

Quindi l’ order(a) sta dicendo: ‘metti prima il terzo elemento quando order(a) …’, mentre il rank(a) sta dicendo, ‘il primo elemento è il secondo più basso …’. (Si noti che entrambi concordano su quale elemento è il più basso, ecc., Ma presentano semplicemente le informazioni in modo diverso.) Quindi vediamo che possiamo usare order() per ordinare, ma non possiamo usare rank() questo modo:

 > a[order(a)] [1] 10 45 50 96 > sort(a) [1] 10 45 50 96 > a[rank(a)] [1] 50 10 45 96 

In generale, order() non sarà uguale a rank() meno che il vettore non sia già stato ordinato:

 > b < - sort(a) > order(b)==rank(b) [1] TRUE TRUE TRUE TRUE 

Inoltre, poiché order() è (essenzialmente) operativo su ranghi dei dati, è ansible comporli senza influire sulle informazioni, ma viceversa produce termini senza senso:

 > order(rank(a))==order(a) [1] TRUE TRUE TRUE TRUE > rank(order(a))==rank(a) [1] FALSE FALSE FALSE TRUE 

L’esecuzione di questo piccolo pezzo di codice mi ha permesso di capire la funzione dell’ordine

 x < - c(3, 22, 5, 1, 77) cbind( index=1:length(x), rank=rank(x), x, order=order(x), sort=sort(x) ) index rank x order sort [1,] 1 2 3 4 1 [2,] 2 4 22 1 3 [3,] 3 3 5 3 5 [4,] 4 1 1 2 22 [5,] 5 5 77 5 77 

Riferimento: http://r.789695.n4.nabble.com/I-don-t-understand-the-order-function-td4664384.html

Questo potrebbe aiutarti ad un certo punto.

 a < - c(45,50,10,96) a[order(a)] 

Quello che ottieni è

 [1] 10 45 50 96 

Il codice che ho scritto indica che vuoi "a" come un intero sottoinsieme di "a" e vuoi che sia ordinato dal valore più basso a quello più alto.

In parole semplici, order() fornisce le posizioni di elementi di grandezza crescente.

Ad esempio, l’ order(c(10,20,30)) darà 1,2,3 e l’ order(c(30,20,10)) darà 3,2,1 .