Sei so dass für eine sehr kurze Stichprobe wie berechnet werden kann aus dem Auffinden der ten Ordnung statischer paarweiser Differenzen: $Q_n = C_n.\{|X_i-X_j|;i < j\}_{(k)}$$\{1,3,6,2,7,5\}$$k$

    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

Also ist$Q_n=C_n. 2$

Offensichtlich benötigen wir für große Samples, die aus 80.000 Datensätzen bestehen, sehr viel Speicher.

Gibt es überhaupt im 1D-Raum anstelle von 2D zu berechnen ?$Q_n$

Ein Link zur Antwort ftp://ftp.win.ua.ac.be/pub/preprints/92/Timeff92.pdf, obwohl ich es nicht vollständig verstehen kann.

Update: Der Kern des Problems besteht darin, dass zum Erreichen der Komplexität von in der Reihenfolge von Speicherplatz benötigt wird.$O(n\log(n))$$O(n)$

Nein, ist die untere theoretische Schranke für die zeitliche Komplexität von (siehe (1)) der Auswahl des -Elements unter allen möglich .$O(n\log(n))$$k^{th}$$\frac{n(n-1)}{2}$$|x_i - x_j|: 1 \leq i \lt j \leq n$

Sie können -Raum erhalten, aber nur, indem Sie naiv alle Kombinationen von in der Zeit überprüfen .$O(1)$$x_i-x_j$$O(n^2)$

Die gute Nachricht ist, dass Sie den in der Funktion im Paket implementierten Skalierungsschätzer (siehe (2) und (3) für eine verbesserte Version und einige Zeitvergleiche verwenden können . Der univariate Schätzer ist ein zweistufiger (dh neu gewichteter) Skalenschätzer. Es hat einen Wirkungsgrad nach Gauß von 95 Prozent, einen Durchschlagspunkt von 50 Prozent und eine Komplexität von -Zeit und -Raum (und es kann problemlos online geschaltet werden), wodurch die Hälfte der Berechnungskosten bei wiederholter Verwendung gespart wird - obwohl Sie müssen in den Code eintauchen, um diese Option zu implementieren, es ist ziemlich einfach zu tun).$\tau$τ O ( n ) O ( 1 )scaleTau2()Rrobustbase$\tau$$O(n)$$O(1)$R

1. Die Komplexität der Auswahl und Rangfolge in X + Y und Matrizen mit sortierten Spalten GN Frederickson und DB Johnson, Journal of Computer and System Sciences, Band 24, Ausgabe 2, April 1982, Seiten 197-208.
2. Yohai, V. und Zamar, R. (1988). Hohe Ausfallpunktschätzungen der Regression durch Minimierung eines effizienten Maßstabs. Zeitschrift der American Statistical Association 83 406–413.
3. Maronna, R. und Zamar, R. (2002). Robuste Schätzungen von Standort und Streuung für hochdimensionale Datensätze. Technometrics 44 307–317

Bearbeiten Um dies zu verwenden

1. Fire up R(kostenlos und kann hier heruntergeladen werden )
2. Installieren Sie das Paket, indem Sie Folgendes eingeben:

install.packages("robustbase")

3. Laden Sie das Paket, indem Sie Folgendes eingeben:

library("robustbase")

4. Laden Sie Ihre Datendatei und führen Sie die Funktion aus:

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

(Sehr kurze Antwort) Der Text zum Kommentieren sagt

Vermeiden Sie es, Fragen in Kommentaren zu beantworten.

Also los geht's: Es gibt eine Abhandlung über einen Online-Algorithmus, der anscheinend recht gut funktioniert$Q_n$ : Anwendung des Q n Estimator Online .

BEARBEITEN

(vom Benutzer user603). Der in diesem Artikel verknüpfte Algorithmus ist eine Moving-Window- Version des .$Q_n$

$\{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}$

$Q_n^i|Q_n^{i-1}$ $O(n\log(n))$$Q_n^i$

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

Das ist mein Werkzeug von Qn ...

Ich habe dies in C programmiert und das Ergebnis ist folgendes:

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;
}