Bırakın böylece gibi çok kısa bir örnek için hesaplanabilir ikili farklılıkların sırası statikini bulmaktan : { 1 , 3 , 6 , 2 , 7 , 5 } $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

Böylece$Q_n=C_n. 2$

Açıkçası 80.000 kayıttan oluşan büyük örnekler için çok büyük bir belleğe ihtiyacımız var.

2D yerine 1B alanda hesaplamak için yine de var mı ?$Q_n$

Tam olarak anlayamama rağmen ftp://ftp.win.ua.ac.be/pub/preprints/92/Timeff92.pdf cevabına bir bağlantı .

Güncelleme: Sorunun temel noktası, zaman karmaşıklığını elde etmek için depolama sırasına ihtiyaç duyulmasıdır.$O(n\log(n))$$O(n)$

Hayır, , tüm arasında öğesini seçmenin zaman karmaşıklığı için alt teorik sınırdır (bakınız (1)) mümkün .$O(n\log(n))$$k^{th}$$\frac{n(n-1)}{2}$$|x_i - x_j|: 1 \leq i \lt j \leq n$

alanı elde edebilirsiniz , ancak sadece zamanında tüm kombinasyonlarını saf bir şekilde kontrol ederek .$O(1)$$x_i-x_j$$O(n^2)$

İyi haber şu ki , paketteki işlevde uygulanan ölçeklendirmenin ölçeklendiricisini (gelişmiş bir sürüm ve bazı zamanlama karşılaştırmaları için bkz. (2) ve (3)) kullanabilirsiniz . Tek değişkenli tahmincisi iki aşamalı (yani yeniden ağırlıklı) bir ölçek tahmincisidir. Yüzde 95 Gauss verimliliği, yüzde 50 kırılma noktası ve zaman ve alanının karmaşıklığı vardır (ayrıca tekrarlanan kullanımda hesaplama maliyetlerinin yarısını tıraş ederek - kolayca çevrimiçi olarak yapılabilir) Bu seçeneği uygulamak için kodu kazmak zorunda kalacak , bunu yapmak oldukça basittir).$\tau$τ O ( n ) O ( 1 )scaleTau2()Rrobustbase$\tau$$O(n)$$O(1)$R

1. X + Y'deki seçim ve sıralamanın karmaşıklığı ve sıralı sütunlarla matrisler GN Frederickson ve DB Johnson, Bilgisayar ve Sistem Bilimleri Dergisi Cilt 24, Sayı 2, Nisan 1982, Sayfa 197-208.
2. Yohai, V. ve Zamar, R. (1988). Etkili ölçeğin minimize edilmesi yoluyla yüksek kırılma noktası regresyon tahminleri. Amerikan İstatistik Derneği Dergisi 4040-413.
3. Maronna, R. ve Zamar, R. (2002). Yüksek boyutlu veri kümeleri için sağlam konum ve dağılım tahminleri. Teknometri 44307–317

Düzenle Bunu kullanmak için

1. Çalıştır R(ücretsiz ve indirilebilir burada )
2. Paketi yazarak yükleyin:

install.packages("robustbase")

3. Paketi yazarak yükleyin:

library("robustbase")

4. Veri dosyanızı yükleyin ve işlevi çalıştırın:

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

(Çok kısa cevap) Yorum metni şöyle diyor

yorumlarda soruları yanıtlamaktan kaçının.

işte burada: Görünüşe göre oldukça iyi çalışan bir çevrimiçi algoritma hakkında bir makale var: Tahmincisi Online'ı uygulama$Q_n$ .

DÜZENLE

(kullanıcı603 kullanıcısı tarafından). Bu makalede bağlı algoritma hareketli bir pencere sürümü sürümüdür .$Q_n$

Büyük bir örnek verilen genişliği zaman penceresi ayrılır , biz uygulayabilir için değerlerini veren her zaman penceresi . Bu değerleri belirtin$\{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}$

Burada belirtilen algoritma ' sıfırdan hesaplamak için gereken en kötü maliyetinden daha düşük bir ortalama maliyetle elde sağlar . O ( n günlüğü ( n ) ) Q i $Q_n^i|Q_n^{i-1}$ $O(n\log(n))$$Q_n^i$

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

Bu benim Qn uygulamak olduğunu ...

Bu C programlama ve sonuç şu:

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