Sia $Q_n = C_n.\{|X_i-X_j|;i < j\}_{(k)}$ quindi per un campione molto breve come $\{1,3,6,2,7,5\}$ può essere calcolato trovando il $k$ ° ordine statico delle differenze a coppie:

    7 6 5 3 2 1
1   6 5 4 2 1
2   5 4 3 1
3   4 3 2
5   2 1
6   1
7

h = [n / 2] + 1 = 4

k = h (h-1) / 2 = 8

Quindi $Q_n=C_n. 2$

Ovviamente per campioni di grandi dimensioni che dicono di 80.000 registrazioni abbiamo bisogno di una memoria molto grande.

Esiste un modo per calcolare nello spazio 1D anziché in 2D?$Q_n$

Un link alla risposta ftp://ftp.win.ua.ac.be/pub/preprints/92/Timeff92.pdf anche se non riesco a comprenderlo appieno.

Aggiornamento: il nocciolo del problema è che per ottenere la complessità temporale $O(n\log(n))$ , è necessario nell'ordine di archiviazione $O(n)$ .

No, $O(n\log(n))$ è il limite teorico inferiore per la complessità temporale di (vedi (1)) selezionando l' elemento $k^{th}$ tra tutti $\frac{n(n-1)}{2}$ possibili$|x_i - x_j|: 1 \leq i \lt j \leq n$.

Puoi ottenere lo spazio $O(1)$ , ma solo controllando ingenuamente tutte le combinazioni di $x_i-x_j$ nel tempo $O(n^2)$ .

La buona notizia è che è possibile utilizzare lo stimatore $\tau$ della scala (vedere (2) e (3) per una versione migliorata e alcuni confronti di temporizzazione), implementato nella funzione scaleTau2()nel Rpacchetto robustbase. Lo stimatore univariato $\tau$ è uno stimatore di scala in due fasi (cioè ripesato). Ha un'efficienza gaussiana del 95 percento, un punto di rottura del 50 percento e la complessità del tempo $O(n)$ e dello spazio $O(1)$ (in più può essere facilmente reso "online", tagliando la metà dei costi di calcolo in un uso ripetuto, sebbene tu dovrà scavare nel Rcodice per implementare questa opzione, è piuttosto semplice da fare).

1. La complessità della selezione e del posizionamento in X + Y e matrici con colonne ordinate GN Frederickson e DB Johnson, Journal of Computer and System Sciences Volume 24, Numero 2, Aprile 1982, Pagine 197-208.
2. Yohai, V. e Zamar, R. (1988). Stime elevate del punto di rottura della regressione mediante la minimizzazione di una scala efficiente. Rivista dell'American Statistical Association 83 406–413.
3. Maronna, R. e Zamar, R. (2002). Stime affidabili di posizione e dispersione per set di dati ad alta dimensione. Technometrics 44 307–317

Modifica Per usare questo

1. Accendi R(è gratuito e può essere scaricato da qui )
2. Installa il pacchetto digitando:

install.packages("robustbase")

3. Carica il pacchetto digitando:

library("robustbase")

4. Carica il tuo file di dati ed esegui la funzione:

mydatavector <- read.table("address to my file in text format", header=T)
scaleTau2(mydatavector)

(Risposta molto breve) Il testo per commentare dice

evitare di rispondere alle domande nei commenti.

quindi eccoci qui: c'è un documento su un algoritmo online che sembra funzionare abbastanza bene: applicare lo stimatore online$Q_n$ .

MODIFICARE

(dall'utente user603). L'algoritmo collegato in questo articolo è una versione della finestra mobile della .$Q_n$

Dato un grande campione diviso in finestre temporali di larghezza n < N , { x i } t i = t - n + 1 possiamo applicare la Q n ad ogni finestra temporale che produce N - n + 1 valori di Q n . Indica questi valori { Q i n } N - n + 1 $\{x_i\}_{i=1}^N$$n<N$$\{x_i\}_{i=t-n+1}^t$$Q_n$$N-n+1$$Q_n$$\{Q_n^i\}_{i=1}^{N-n+1}$

L'algoritmo qui citato consente di ottenere a un costo medio inferiore al caso peggiore O ( n log ( n ) ) necessario per calcolare Q i n da zero.$Q_n^i|Q_n^{i-1}$ $O(n\log(n))$$Q_n^i$

$Q_n$$\{x_i\}_{i=1}^N$$O(n^2)$

questo è il mio strumento di Qn ...

Lo stavo programmando in C e il risultato è questo:

void bubbleSort(double *datos, int N)
{
 for (int j=0; j<N-1 ;j++)     
  for (int i=j+1; i<N; i++)    
   if (datos[i]<datos[j])      
   {
    double tmp=datos[i];
    datos[i]=datos[j];
    datos[j]=tmp;
   }
}

double  fFactorial(long N)    
{
 double factorial=1.0;

 for (long i=1; i<=N; ++i)
  factorial*=(double)i;

 return factorial;  
}

double fQ_n(double *datos, int N)  // Rousseeuw's and Croux (1993) Qn scale estimator
{
 bubbleSort(datos, N);

 int m=(int)((fFactorial((long)N))/(fFactorial(2)*fFactorial((long)N-2)));

 double D[m];
 //double Cn=2.2219;      //not used now :) constant value https://www.itl.nist.gov/div898/software/dataplot/refman2/auxillar/qn_scale.htm

 int k=(int)((fFactorial((long)N/2+1))/(fFactorial(2)*fFactorial((long)N/2+1-2)));

 int y=0;

 for (int i=0; i<N; i++)
  for (int j=N-1; j>=0; j--)
   if (i<j)
   {
    D[y]=abs(datos[i]-datos[j]);
    y++;
   }

 bubbleSort(D, m);

 return D[k-1];
}

int main(int argc, char **argv)    
{
 double datos[6]={1,2,3,5,6,7};
 int N=6;

 // Priting in terminal the final solution
 printf("\n==[Results] ========================================\n\n");

 printf(" Q_n=%0.3f\n",fQ_n(datos,N));

 return 0;
}