The implementations evaluate an expected median area arising from a random rectangle construction. After normalizing two complementary horizontal gaps and two complementary vertical gaps, the geometry depends only on two ratios \(x,y\in[0,1]\). The target value becomes a two-dimensional integral of a normalized kernel, followed by a constant rescaling by \(1/4\).
Introduce the complementary fractions
$$x_0=1-x,\qquad y_0=1-y.$$
The normalized geometry is completely determined by these four numbers. Each admissible relative arrangement contributes the median of three candidate areas, and the kernel is the average over six equally weighted arrangements.
For any triple \((a,b,c)\), the median can be written without sorting as
$$\operatorname{med}(a,b,c)=a+b+c-\min(a,b,c)-\max(a,b,c).$$
This identity is exactly what the implementation uses. It avoids a separate ordering step and gives the middle value directly.
From the normalized side fractions, the six median terms are
$$\begin{aligned} T_1(x,y)&=\operatorname{med}(xy,\ x_0y_0,\ 1),\\ T_2(x,y)&=\operatorname{med}(xy,\ x_0,\ y_0),\\ T_3(x,y)&=\operatorname{med}(xy_0,\ x_0y,\ 1),\\ T_4(x,y)&=\operatorname{med}(xy_0,\ x_0,\ y),\\ T_5(x,y)&=\operatorname{med}(x,\ x_0y,\ y_0),\\ T_6(x,y)&=\operatorname{med}(x,\ x_0y_0,\ y). \end{aligned}$$
The normalized kernel is their average:
$$M(x,y)=\frac{T_1(x,y)+T_2(x,y)+T_3(x,y)+T_4(x,y)+T_5(x,y)+T_6(x,y)}{6}.$$
This formula is the mathematical core of the solution: once \(M(x,y)\) is available, the rest of the task is numerical integration.
Replacing \(x\) with \(1-x\), replacing \(y\) with \(1-y\), or swapping \(x\) and \(y\) only permutes the six triples above. Therefore
$$M(x,y)=M(1-x,y)=M(x,1-y)=M(y,x).$$
These identities are important for two reasons. First, they confirm that the six-term average has the expected geometric symmetry. Second, they justify computing the double quadrature with symmetry in the node indices.
The normalized mean contribution is
$$J=\int_0^1\int_0^1 M(x,y)\,dx\,dy.$$
After the geometric normalization, the original expected area is obtained by multiplying by the scale factor left outside the ratio variables. In the implemented derivation that factor is \(1/4\), so the final quantity is
$$E=\frac{J}{4}.$$
The entire computational problem is therefore reduced to evaluating \(J\) very accurately.
Let \((\xi_i,w_i)_{i=1}^n\) be the \(n\)-point Gauss-Legendre nodes and weights on \([0,1]\). Then
$$J_n=\sum_{i=1}^{n}\sum_{j=1}^{n} w_i w_j M(\xi_i,\xi_j)$$
approximates \(J\). Because the kernel is symmetric in its two arguments, the implementations reorganize the sum as
$$J_n=\sum_{i=1}^{n} w_i^2 M(\xi_i,\xi_i)+2\sum_{1\le i\lt j\le n} w_i w_j M(\xi_i,\xi_j).$$
This keeps the same quadrature rule while cutting the off-diagonal work almost in half.
The kernel is smooth inside regions separated by median-switching boundaries, so the global quadrature error behaves like a piecewise-smooth integral rather than a fully analytic one. The implementation models the leading term as
$$E_n=E+\frac{C}{n^2}+O\left(\frac{1}{n^4}\right).$$
Computing once with \(n\) nodes and once with \(2n\) nodes gives
$$E_{2n}=E+\frac{C}{4n^2}+O\left(\frac{1}{n^4}\right).$$
Eliminating the unknown constant \(C\) yields
$$E_{\text{rich}}=E_{2n}+\frac{E_{2n}-E_n}{3}.$$
This Richardson-refined value is the reported answer.
Here \(x_0=1\) and \(y_0=\frac{3}{4}\). The six median terms become
$$\begin{aligned} T_1&=\operatorname{med}\left(0,\frac{3}{4},1\right)=\frac{3}{4},\\ T_2&=\operatorname{med}\left(0,1,\frac{3}{4}\right)=\frac{3}{4},\\ T_3&=\operatorname{med}\left(0,\frac{1}{4},1\right)=\frac{1}{4},\\ T_4&=\operatorname{med}\left(0,1,\frac{1}{4}\right)=\frac{1}{4},\\ T_5&=\operatorname{med}\left(0,\frac{1}{4},\frac{3}{4}\right)=\frac{1}{4},\\ T_6&=\operatorname{med}\left(0,\frac{3}{4},\frac{1}{4}\right)=\frac{1}{4}. \end{aligned}$$
Therefore
$$M\left(0,\frac{1}{4}\right)=\frac{\frac{3}{4}+\frac{3}{4}+\frac{1}{4}+\frac{1}{4}+\frac{1}{4}+\frac{1}{4}}{6}=\frac{5}{12},$$
which is one of the checkpoint values verified by the implementation.
The C++, Python, and Java implementations all follow the same numerical plan. They evaluate the six median expressions for any requested pair \((x,y)\), generate Gauss-Legendre nodes and weights on \([0,1]\) from Legendre roots, and accumulate the symmetric double sum for two resolutions, \(n\) and \(2n\).
Each integral approximation is divided by \(4\), then the two results are combined with Richardson extrapolation. The C++ and Java implementations parallelize the outer loop over quadrature rows, while the Python implementation delegates to the compiled numerical solver and returns the parsed final value.
Before reporting the answer, the workflow checks fixed kernel values, symmetry identities, and benchmark quadrature outputs at moderate orders. Those checks guard against both algebraic mistakes in the kernel and numerical mistakes in the quadrature generator.
For order \(n\), generating the Gauss-Legendre nodes and weights costs \(O(n^2)\) arithmetic overall because each root evaluation uses a degree-\(n\) recurrence and there are \(O(n)\) roots. The dominant cost is the double quadrature itself, which requires \(O(n^2)\) kernel evaluations and \(O(n)\) memory for the node and weight arrays. Because the sum is split by rows, the wall-clock time benefits directly from multi-core parallelism.
Die Implementierungen berechnen einen erwarteten Medianflächenwert aus einer Zufallskonstruktion mit Rechtecken. Nach der Normalisierung zweier komplementärer horizontaler Abstände und zweier komplementärer vertikaler Abstände hängt die Geometrie nur noch von zwei Verhältnissen \(x,y\in[0,1]\) ab. Die Zielgröße wird dadurch zu einem zweidimensionalen Integral eines normierten Kerns, gefolgt von einer konstanten Reskalierung mit \(1/4\).
Wir führen die komplementären Anteile
$$x_0=1-x,\qquad y_0=1-y$$
ein. Die normierte Geometrie ist damit vollständig festgelegt. Jede zulässige relative Anordnung liefert den Median von drei Kandidatenflächen, und der Kern entsteht als Mittelwert über sechs gleich gewichtete Anordnungen.
Für ein beliebiges Tripel \((a,b,c)\) lässt sich der Median ohne Sortieren schreiben als
$$\operatorname{med}(a,b,c)=a+b+c-\min(a,b,c)-\max(a,b,c).$$
Genau diese Identität verwendet die Implementierung. Man erhält damit unmittelbar den mittleren Wert der drei Eingaben.
Aus den normierten Seitenanteilen entstehen die sechs Medianterme
$$\begin{aligned} T_1(x,y)&=\operatorname{med}(xy,\ x_0y_0,\ 1),\\ T_2(x,y)&=\operatorname{med}(xy,\ x_0,\ y_0),\\ T_3(x,y)&=\operatorname{med}(xy_0,\ x_0y,\ 1),\\ T_4(x,y)&=\operatorname{med}(xy_0,\ x_0,\ y),\\ T_5(x,y)&=\operatorname{med}(x,\ x_0y,\ y_0),\\ T_6(x,y)&=\operatorname{med}(x,\ x_0y_0,\ y). \end{aligned}$$
Der normierte Kern ist ihr Durchschnitt:
$$M(x,y)=\frac{T_1(x,y)+T_2(x,y)+T_3(x,y)+T_4(x,y)+T_5(x,y)+T_6(x,y)}{6}.$$
Das ist der mathematische Kern der Lösung: Sobald \(M(x,y)\) feststeht, bleibt nur noch eine hochgenaue numerische Integration.
Ersetzt man \(x\) durch \(1-x\), \(y\) durch \(1-y\) oder vertauscht \(x\) und \(y\), so werden die sechs Tripel nur permutiert. Daher gilt
$$M(x,y)=M(1-x,y)=M(x,1-y)=M(y,x).$$
Diese Identitäten sind aus zwei Gründen wichtig. Erstens bestätigen sie die erwartete geometrische Symmetrie des Sechsermittels. Zweitens erlauben sie, die doppelte Quadratur mit Symmetrie in den Knotenindizes auszuwerten.
Der normierte mittlere Beitrag ist
$$J=\int_0^1\int_0^1 M(x,y)\,dx\,dy.$$
Nach der geometrischen Normalisierung erhält man die ursprüngliche Erwartungsfläche durch Multiplikation mit dem Skalenfaktor, der außerhalb der Verhältnisvariablen übrig bleibt. In der implementierten Herleitung ist dieser Faktor \(1/4\), also
$$E=\frac{J}{4}.$$
Damit reduziert sich die gesamte Aufgabe auf die sehr genaue Berechnung von \(J\).
Seien \((\xi_i,w_i)_{i=1}^n\) die \(n\)-Punkt-Gauß-Legendre-Knoten und -Gewichte auf \([0,1]\). Dann ist
$$J_n=\sum_{i=1}^{n}\sum_{j=1}^{n} w_i w_j M(\xi_i,\xi_j)$$
eine Approximation für \(J\). Wegen der Symmetrie des Kerns in beiden Argumenten ordnen die Implementierungen die Summe um zu
$$J_n=\sum_{i=1}^{n} w_i^2 M(\xi_i,\xi_i)+2\sum_{1\le i\lt j\le n} w_i w_j M(\xi_i,\xi_j).$$
Die Quadraturregel bleibt dieselbe, aber der Aufwand für die Nebendiagonale wird fast halbiert.
Der Kern ist innerhalb von Regionen glatt, die durch Medianwechsel-Grenzen getrennt sind. Deshalb verhält sich der globale Quadraturfehler wie bei einem stückweise glatten Integral und nicht wie bei einer vollständig analytischen Funktion. Die Implementierung modelliert den führenden Term als
$$E_n=E+\frac{C}{n^2}+O\left(\frac{1}{n^4}\right).$$
Mit Rechnungen für \(n\) und \(2n\) Knoten erhält man
$$E_{2n}=E+\frac{C}{4n^2}+O\left(\frac{1}{n^4}\right).$$
Durch Eliminieren der unbekannten Konstante \(C\) folgt
$$E_{\text{rich}}=E_{2n}+\frac{E_{2n}-E_n}{3}.$$
Dieser Richardson-verfeinerte Wert ist das ausgegebene Resultat.
Hier sind \(x_0=1\) und \(y_0=\frac{3}{4}\). Die sechs Medianterme lauten
$$\begin{aligned} T_1&=\operatorname{med}\left(0,\frac{3}{4},1\right)=\frac{3}{4},\\ T_2&=\operatorname{med}\left(0,1,\frac{3}{4}\right)=\frac{3}{4},\\ T_3&=\operatorname{med}\left(0,\frac{1}{4},1\right)=\frac{1}{4},\\ T_4&=\operatorname{med}\left(0,1,\frac{1}{4}\right)=\frac{1}{4},\\ T_5&=\operatorname{med}\left(0,\frac{1}{4},\frac{3}{4}\right)=\frac{1}{4},\\ T_6&=\operatorname{med}\left(0,\frac{3}{4},\frac{1}{4}\right)=\frac{1}{4}. \end{aligned}$$
Daher
$$M\left(0,\frac{1}{4}\right)=\frac{\frac{3}{4}+\frac{3}{4}+\frac{1}{4}+\frac{1}{4}+\frac{1}{4}+\frac{1}{4}}{6}=\frac{5}{12},$$
genau einer der Kontrollwerte, die die Implementierung überprüft.
Die C++-, Python- und Java-Implementierungen folgen alle demselben numerischen Plan. Zuerst werten sie für ein gegebenes Paar \((x,y)\) die sechs Medianterme aus, dann erzeugen sie aus den Legendre-Nullstellen die Gauß-Legendre-Knoten und -Gewichte auf \([0,1]\), und anschließend akkumulieren sie die symmetrische Doppelsumme für zwei Auflösungen, \(n\) und \(2n\).
Jede Integralnäherung wird durch \(4\) geteilt, danach werden die beiden Ergebnisse per Richardson-Extrapolation kombiniert. Die C++- und Java-Implementierungen parallelisieren die äußere Schleife über Quadraturzeilen, während die Python-Implementierung den kompilierten numerischen Solver aufruft und den endgültigen Zahlenwert aus dessen Ausgabe übernimmt.
Bevor das Ergebnis ausgegeben wird, prüft der Ablauf feste Kernwerte, Symmetrieidentitäten und Referenzwerte der Quadratur bei mittleren Ordnungen. Diese Kontrollen schützen sowohl vor algebraischen Fehlern im Kern als auch vor numerischen Fehlern im Quadraturgenerator.
Für Ordnung \(n\) kostet die Erzeugung der Gauß-Legendre-Knoten und -Gewichte insgesamt \(O(n^2)\) Rechenoperationen, weil jede Nullstelle über eine Rekursion vom Grad \(n\) ausgewertet wird und es \(O(n)\) Nullstellen gibt. Der dominierende Anteil ist die doppelte Quadratur selbst: Sie benötigt \(O(n^2)\) Kernauswertungen und \(O(n)\) Speicher für Knoten- und Gewichtsfelder. Da die Summe zeilenweise aufgeteilt wird, profitiert die Laufzeit direkt von Mehrkern-Parallelität.
Uygulamalar, rastgele bir dikdörtgen kurgusundan doğan beklenen medyan alanı hesaplar. İki tamamlayıcı yatay aralık ve iki tamamlayıcı dikey aralık normalize edildikten sonra geometri yalnızca \(x,y\in[0,1]\) oranlarına bağlı kalır. Hedef değer böylece normalize bir çekirdeğin iki boyutlu integraline, ardından da sabit \(1/4\) ölçek çarpanına indirgenir.
Tamamlayıcı oranları
$$x_0=1-x,\qquad y_0=1-y$$
olarak tanımlayalım. Normalize geometri bu dört sayı ile tamamen belirlenir. Her geçerli göreli yerleşim, üç aday alanın medyanını üretir; çekirdek fonksiyon da eşit ağırlıklı altı yerleşimin ortalamasıdır.
Herhangi bir \((a,b,c)\) üçlüsü için medyan, sıralama yapmadan
$$\operatorname{med}(a,b,c)=a+b+c-\min(a,b,c)-\max(a,b,c)$$
şeklinde yazılabilir. Uygulama tam olarak bu özdeşliği kullanır. Böylece üç değerin ortadaki elemanı doğrudan elde edilir.
Normalize kenar oranlarından gelen altı medyan terimi şunlardır:
$$\begin{aligned} T_1(x,y)&=\operatorname{med}(xy,\ x_0y_0,\ 1),\\ T_2(x,y)&=\operatorname{med}(xy,\ x_0,\ y_0),\\ T_3(x,y)&=\operatorname{med}(xy_0,\ x_0y,\ 1),\\ T_4(x,y)&=\operatorname{med}(xy_0,\ x_0,\ y),\\ T_5(x,y)&=\operatorname{med}(x,\ x_0y,\ y_0),\\ T_6(x,y)&=\operatorname{med}(x,\ x_0y_0,\ y). \end{aligned}$$
Normalize çekirdek bunların ortalamasıdır:
$$M(x,y)=\frac{T_1(x,y)+T_2(x,y)+T_3(x,y)+T_4(x,y)+T_5(x,y)+T_6(x,y)}{6}.$$
Çözümün matematiksel özü budur: \(M(x,y)\) kurulduktan sonra geriye yalnızca bu fonksiyonun yüksek doğrulukla integrali kalır.
\(x\)'i \(1-x\) ile değiştirmek, \(y\)'yi \(1-y\) ile değiştirmek ya da \(x\) ve \(y\)'yi yer değiştirmek, yukarıdaki altı üçlüyü sadece yeniden sıralar. Bu nedenle
$$M(x,y)=M(1-x,y)=M(x,1-y)=M(y,x).$$
Bu özdeşlikler iki açıdan önemlidir. Birincisi, altılı ortalamanın beklenen geometrik simetriyi taşıdığını gösterirler. İkincisi, düğüm indislerinde simetri kullanılarak çift integrali daha verimli toplamaya izin verirler.
Normalize ortalama katkı
$$J=\int_0^1\int_0^1 M(x,y)\,dx\,dy$$
şeklindedir. Geometrik normalizasyondan sonra, oran değişkenlerinin dışında kalan ölçek çarpanı orijinal beklenen alanı geri getirir. Uygulanan türetimde bu çarpan \(1/4\) olduğundan nihai büyüklük
$$E=\frac{J}{4}$$
olur. Dolayısıyla hesaplamanın tamamı \(J\)'yi çok hassas biçimde bulma problemine indirgenir.
\([0,1]\) aralığındaki \(n\)-noktalı Gauss-Legendre düğüm ve ağırlıkları \((\xi_i,w_i)_{i=1}^n\) olsun. O zaman
$$J_n=\sum_{i=1}^{n}\sum_{j=1}^{n} w_i w_j M(\xi_i,\xi_j)$$
\(J\) için yüksek doğruluklu bir yaklaşımdır. Çekirdek iki değişkende simetrik olduğu için uygulamalar toplamı şu biçimde düzenler:
$$J_n=\sum_{i=1}^{n} w_i^2 M(\xi_i,\xi_i)+2\sum_{1\le i\lt j\le n} w_i w_j M(\xi_i,\xi_j).$$
Böylece aynı kuadratür kuralı korunurken köşegen dışı değerlendirmelerin sayısı neredeyse yarıya iner.
Çekirdek, medyanın değiştiği sınırlarla ayrılan bölgelerin içinde düzgündür. Bu yüzden küresel kuadratür hatası tamamen analitik bir fonksiyondan değil, parçalı düzgün bir integralden beklenen şekilde davranır. Uygulama baskın terimi
$$E_n=E+\frac{C}{n^2}+O\left(\frac{1}{n^4}\right)$$
olarak modeller. \(n\) ve \(2n\) düğümle yapılan iki hesap
$$E_{2n}=E+\frac{C}{4n^2}+O\left(\frac{1}{n^4}\right)$$
verir. Buradan bilinmeyen \(C\) elimine edilince
$$E_{\text{rich}}=E_{2n}+\frac{E_{2n}-E_n}{3}$$
elde edilir. Raporlanan son değer budur.
Bu durumda \(x_0=1\) ve \(y_0=\frac{3}{4}\) olur. Altı medyan terimi
$$\begin{aligned} T_1&=\operatorname{med}\left(0,\frac{3}{4},1\right)=\frac{3}{4},\\ T_2&=\operatorname{med}\left(0,1,\frac{3}{4}\right)=\frac{3}{4},\\ T_3&=\operatorname{med}\left(0,\frac{1}{4},1\right)=\frac{1}{4},\\ T_4&=\operatorname{med}\left(0,1,\frac{1}{4}\right)=\frac{1}{4},\\ T_5&=\operatorname{med}\left(0,\frac{1}{4},\frac{3}{4}\right)=\frac{1}{4},\\ T_6&=\operatorname{med}\left(0,\frac{3}{4},\frac{1}{4}\right)=\frac{1}{4} \end{aligned}$$
şeklindedir. Dolayısıyla
$$M\left(0,\frac{1}{4}\right)=\frac{\frac{3}{4}+\frac{3}{4}+\frac{1}{4}+\frac{1}{4}+\frac{1}{4}+\frac{1}{4}}{6}=\frac{5}{12},$$
ve bu değer uygulamanın doğruladığı kontrol noktalarından biridir.
C++, Python ve Java uygulamaları aynı sayısal planı izler. Önce verilen bir \((x,y)\) çifti için altı medyan terimini hesaplarlar; sonra Legendre köklerinden \([0,1]\) üzerindeki Gauss-Legendre düğüm ve ağırlıklarını üretirler; ardından da \(n\) ve \(2n\) çözünürlükleri için simetrik çift toplamı biriktirirler.
Her integral yaklaşımı \(4\)'e bölünür, sonra iki sonuç Richardson ekstrapolasyonu ile birleştirilir. C++ ve Java uygulamaları kuadratür satırları üzerindeki dış döngüyü paralelleştirir. Python uygulaması ise derlenmiş sayısal çözücüyü çağırır ve nihai sayısal değeri ayrıştırarak döndürür.
Cevap üretilmeden önce iş akışı sabit çekirdek değerlerini, simetri özdeşliklerini ve orta büyüklükte kuadratür mertebeleri için referans sonuçları denetler. Bu kontroller hem çekirdekteki cebirsel hatalara hem de kuadratür üreticisindeki sayısal hatalara karşı güvence sağlar.
Mertebe \(n\) için Gauss-Legendre düğüm ve ağırlıklarını üretmek toplamda \(O(n^2)\) aritmetik işlem gerektirir; çünkü her kök hesabı derece \(n\) olan bir yineleme kullanır ve toplam \(O(n)\) kök vardır. Baskın maliyet çift kuadratür toplamıdır: bu aşama \(O(n^2)\) çekirdek değerlendirmesi ve düğüm-ağırlık dizileri için \(O(n)\) bellek ister. Toplam satırlara bölündüğü için çalışma süresi çok çekirdekli sistemlerde doğrudan kısalır.
Las implementaciones calculan un valor esperado de un área mediana que surge de una construcción aleatoria con rectángulos. Después de normalizar dos separaciones horizontales complementarias y dos separaciones verticales complementarias, la geometría depende solo de dos razones \(x,y\in[0,1]\). La cantidad buscada se convierte así en una integral bidimensional de un núcleo normalizado, seguida por una reescala constante de \(1/4\).
Introducimos las fracciones complementarias
$$x_0=1-x,\qquad y_0=1-y.$$
La geometría normalizada queda totalmente determinada por estos cuatro números. Cada disposición relativa admisible aporta la mediana de tres áreas candidatas, y el núcleo final es el promedio de seis disposiciones equiprobables.
Para cualquier triple \((a,b,c)\), la mediana puede escribirse sin ordenar como
$$\operatorname{med}(a,b,c)=a+b+c-\min(a,b,c)-\max(a,b,c).$$
La implementación usa exactamente esta identidad. Así obtiene de forma directa el valor intermedio de los tres números.
A partir de las fracciones laterales normalizadas se obtienen los seis términos
$$\begin{aligned} T_1(x,y)&=\operatorname{med}(xy,\ x_0y_0,\ 1),\\ T_2(x,y)&=\operatorname{med}(xy,\ x_0,\ y_0),\\ T_3(x,y)&=\operatorname{med}(xy_0,\ x_0y,\ 1),\\ T_4(x,y)&=\operatorname{med}(xy_0,\ x_0,\ y),\\ T_5(x,y)&=\operatorname{med}(x,\ x_0y,\ y_0),\\ T_6(x,y)&=\operatorname{med}(x,\ x_0y_0,\ y). \end{aligned}$$
El núcleo normalizado es su promedio:
$$M(x,y)=\frac{T_1(x,y)+T_2(x,y)+T_3(x,y)+T_4(x,y)+T_5(x,y)+T_6(x,y)}{6}.$$
Esta es la pieza matemática central de la solución: una vez construido \(M(x,y)\), lo que queda es integrar esa función con gran precisión.
Sustituir \(x\) por \(1-x\), sustituir \(y\) por \(1-y\) o intercambiar \(x\) e \(y\) solo permuta los seis triples anteriores. Por tanto,
$$M(x,y)=M(1-x,y)=M(x,1-y)=M(y,x).$$
Estas identidades son valiosas por dos motivos. Primero, confirman que el promedio de seis términos respeta la simetría geométrica esperada. Segundo, permiten reorganizar la cuadratura doble usando simetría en los índices.
La contribución media normalizada es
$$J=\int_0^1\int_0^1 M(x,y)\,dx\,dy.$$
Tras la normalización geométrica, el área esperada original se recupera multiplicando por el factor de escala que queda fuera de las variables de razón. En la derivación implementada ese factor es \(1/4\), de modo que
$$E=\frac{J}{4}.$$
En consecuencia, todo el problema computacional se reduce a evaluar \(J\) con mucha exactitud.
Sean \((\xi_i,w_i)_{i=1}^n\) los nodos y pesos de Gauss-Legendre de orden \(n\) sobre \([0,1]\). Entonces
$$J_n=\sum_{i=1}^{n}\sum_{j=1}^{n} w_i w_j M(\xi_i,\xi_j)$$
aproxima a \(J\). Como el núcleo es simétrico en sus dos argumentos, las implementaciones reescriben la suma como
$$J_n=\sum_{i=1}^{n} w_i^2 M(\xi_i,\xi_i)+2\sum_{1\le i\lt j\le n} w_i w_j M(\xi_i,\xi_j).$$
Se mantiene la misma regla de cuadratura, pero el trabajo fuera de la diagonal se reduce casi a la mitad.
El núcleo es suave dentro de regiones separadas por fronteras donde cambia la mediana. Por ello, el error global de cuadratura se comporta como el de una integral a trozos suave, no como el de una función completamente analítica. La implementación modela el término principal como
$$E_n=E+\frac{C}{n^2}+O\left(\frac{1}{n^4}\right).$$
Al calcular también con \(2n\) nodos se obtiene
$$E_{2n}=E+\frac{C}{4n^2}+O\left(\frac{1}{n^4}\right).$$
Eliminando la constante desconocida \(C\), resulta
$$E_{\text{rich}}=E_{2n}+\frac{E_{2n}-E_n}{3}.$$
Ese valor refinado por Richardson es el que finalmente se informa.
Aquí \(x_0=1\) y \(y_0=\frac{3}{4}\). Los seis términos medianos quedan
$$\begin{aligned} T_1&=\operatorname{med}\left(0,\frac{3}{4},1\right)=\frac{3}{4},\\ T_2&=\operatorname{med}\left(0,1,\frac{3}{4}\right)=\frac{3}{4},\\ T_3&=\operatorname{med}\left(0,\frac{1}{4},1\right)=\frac{1}{4},\\ T_4&=\operatorname{med}\left(0,1,\frac{1}{4}\right)=\frac{1}{4},\\ T_5&=\operatorname{med}\left(0,\frac{1}{4},\frac{3}{4}\right)=\frac{1}{4},\\ T_6&=\operatorname{med}\left(0,\frac{3}{4},\frac{1}{4}\right)=\frac{1}{4}. \end{aligned}$$
Por tanto,
$$M\left(0,\frac{1}{4}\right)=\frac{\frac{3}{4}+\frac{3}{4}+\frac{1}{4}+\frac{1}{4}+\frac{1}{4}+\frac{1}{4}}{6}=\frac{5}{12},$$
que coincide con uno de los valores de control verificados por la implementación.
Las implementaciones en C++, Python y Java siguen el mismo plan numérico. Primero evalúan los seis términos medianos para cualquier par \((x,y)\), luego generan los nodos y pesos de Gauss-Legendre en \([0,1]\) a partir de las raíces de Legendre, y después acumulan la suma doble simétrica para dos resoluciones, \(n\) y \(2n\).
Cada aproximación integral se divide entre \(4\), y después los dos resultados se combinan con extrapolación de Richardson. Las implementaciones en C++ y Java paralelizan el bucle exterior sobre las filas de la cuadratura, mientras que la implementación en Python delega el trabajo al solucionador numérico compilado y devuelve el valor final ya interpretado.
Antes de producir la respuesta, el flujo comprueba valores fijos del núcleo, identidades de simetría y resultados de referencia de la cuadratura para órdenes moderados. Esas comprobaciones detectan tanto errores algebraicos en el núcleo como errores numéricos en el generador de cuadratura.
Para orden \(n\), generar los nodos y pesos de Gauss-Legendre cuesta \(O(n^2)\) operaciones aritméticas en total, porque cada raíz se evalúa con una recurrencia de grado \(n\) y hay \(O(n)\) raíces. El coste dominante es la cuadratura doble, que requiere \(O(n^2)\) evaluaciones del núcleo y \(O(n)\) memoria para los arreglos de nodos y pesos. Como la suma se reparte por filas, el tiempo de ejecución mejora de forma directa en hardware multinúcleo.
这些实现要计算的是一个随机矩形构型所对应的“中位面积的期望值”。把两段互补的水平间隔和两段互补的垂直间隔做归一化之后，几何信息只剩下两个比值 \(x,y\in[0,1]\)。于是目标量可以写成一个归一化核函数的二维积分，最后再乘上固定缩放因子 \(1/4\)。
先引入互补比例
$$x_0=1-x,\qquad y_0=1-y.$$
这样一来，归一化后的几何结构就完全由这四个量决定。每一种允许的相对排布都会给出三个候选面积，其贡献取这三个数的中位数；整个核函数则是六种等权排布的平均值。
对于任意三元组 \((a,b,c)\)，中位数不必真的排序，也可以直接写成
$$\operatorname{med}(a,b,c)=a+b+c-\min(a,b,c)-\max(a,b,c).$$
实现中正是使用这个恒等式来求三者的中间值。这样既直接，又避免了单独的排序过程。
由归一化边长比例得到的六个中位项是
$$\begin{aligned} T_1(x,y)&=\operatorname{med}(xy,\ x_0y_0,\ 1),\\ T_2(x,y)&=\operatorname{med}(xy,\ x_0,\ y_0),\\ T_3(x,y)&=\operatorname{med}(xy_0,\ x_0y,\ 1),\\ T_4(x,y)&=\operatorname{med}(xy_0,\ x_0,\ y),\\ T_5(x,y)&=\operatorname{med}(x,\ x_0y,\ y_0),\\ T_6(x,y)&=\operatorname{med}(x,\ x_0y_0,\ y). \end{aligned}$$
因此归一化核函数为
$$M(x,y)=\frac{T_1(x,y)+T_2(x,y)+T_3(x,y)+T_4(x,y)+T_5(x,y)+T_6(x,y)}{6}.$$
这就是整个解法的数学核心。只要能够稳定地计算 \(M(x,y)\)，剩下的问题就变成怎样高精度地积分它。
把 \(x\) 替换成 \(1-x\)，把 \(y\) 替换成 \(1-y\)，或者交换 \(x\) 与 \(y\)，都只会重新排列上面的六个三元组，不会改变平均值。因此有
$$M(x,y)=M(1-x,y)=M(x,1-y)=M(y,x).$$
这些对称关系有两个作用。第一，它们说明六项平均确实保留了原问题应有的几何对称性。第二，它们允许在双重求积时只计算上三角部分，再用对称性补回另一半。
归一化后的平均贡献定义为
$$J=\int_0^1\int_0^1 M(x,y)\,dx\,dy.$$
在几何归一化之后，原始期望面积还要乘上一个与比例变量无关的整体尺度因子。按照实现中采用的推导，这个因子正好是 \(1/4\)，所以最终目标量为
$$E=\frac{J}{4}.$$
因此，整个计算任务被压缩成一个高精度求 \(J\) 的数值积分问题。
设 \((\xi_i,w_i)_{i=1}^n\) 是区间 \([0,1]\) 上的 \(n\) 点 Gauss-Legendre 节点与权重，则
$$J_n=\sum_{i=1}^{n}\sum_{j=1}^{n} w_i w_j M(\xi_i,\xi_j)$$
就是 \(J\) 的高精度近似。由于核函数在两个变量上满足对称性，实际实现把它改写为
$$J_n=\sum_{i=1}^{n} w_i^2 M(\xi_i,\xi_i)+2\sum_{1\le i\lt j\le n} w_i w_j M(\xi_i,\xi_j).$$
这样不会改变求积公式本身，但可以把非对角项的核函数计算次数几乎减半。
由于中位数切换会形成分段边界，核函数并不是处处解析，而是在若干区域内部光滑、跨区域边界时改变表达式。因此全局求积误差更像“分段光滑积分”的误差。实现中把主导误差建模为
$$E_n=E+\frac{C}{n^2}+O\left(\frac{1}{n^4}\right).$$
如果再计算一遍 \(2n\) 点求积，就有
$$E_{2n}=E+\frac{C}{4n^2}+O\left(\frac{1}{n^4}\right).$$
消去未知常数 \(C\) 后得到
$$E_{\text{rich}}=E_{2n}+\frac{E_{2n}-E_n}{3}.$$
这个经过 Richardson 修正的数值，就是最终输出的答案。
此时 \(x_0=1\)，\(y_0=\frac{3}{4}\)。六个中位项分别为
$$\begin{aligned} T_1&=\operatorname{med}\left(0,\frac{3}{4},1\right)=\frac{3}{4},\\ T_2&=\operatorname{med}\left(0,1,\frac{3}{4}\right)=\frac{3}{4},\\ T_3&=\operatorname{med}\left(0,\frac{1}{4},1\right)=\frac{1}{4},\\ T_4&=\operatorname{med}\left(0,1,\frac{1}{4}\right)=\frac{1}{4},\\ T_5&=\operatorname{med}\left(0,\frac{1}{4},\frac{3}{4}\right)=\frac{1}{4},\\ T_6&=\operatorname{med}\left(0,\frac{3}{4},\frac{1}{4}\right)=\frac{1}{4}. \end{aligned}$$
所以
$$M\left(0,\frac{1}{4}\right)=\frac{\frac{3}{4}+\frac{3}{4}+\frac{1}{4}+\frac{1}{4}+\frac{1}{4}+\frac{1}{4}}{6}=\frac{5}{12},$$
这正是实现里用于校验的固定检查值之一。
C++、Python 和 Java 的实现遵循同一套数值流程。首先，它们对任意给定的 \((x,y)\) 计算六个中位项；接着通过求 Legendre 多项式的零点，生成区间 \([0,1]\) 上的 Gauss-Legendre 节点与权重；然后分别在 \(n\) 和 \(2n\) 两个分辨率下累加对称形式的双重求和。
每个积分近似值都会先除以 \(4\)，再用 Richardson 外推把两个结果合成为更精细的估计。C++ 和 Java 实现把外层的求积行循环并行化，而 Python 实现则调用编译后的数值求解器，并解析其最终输出的数值。
在给出答案之前，整个流程还会检查若干固定核函数值、对称恒等式，以及中等阶数求积时的参考结果。这些检查同时覆盖了核函数公式是否写对，以及求积节点与权重是否生成正确。
对于阶数 \(n\)，生成 Gauss-Legendre 节点和权重总体需要 \(O(n^2)\) 次算术操作，因为每个根的求解都要使用一个 \(n\) 次递推，而根的数量本身是 \(O(n)\)。主导成本来自双重求积，它需要 \(O(n^2)\) 次核函数评估，并只需要 \(O(n)\) 的额外内存来保存节点和权重数组。由于求和按行拆分，多核并行能够直接缩短实际运行时间。
Реализации вычисляют математическое ожидание медианной площади, возникающей в случайной прямоугольной конструкции. После нормировки двух дополняющих друг друга горизонтальных промежутков и двух дополняющих вертикальных промежутков геометрия зависит только от двух отношений \(x,y\in[0,1]\). Поэтому искомая величина сводится к двумерному интегралу от нормированного ядра с последующим умножением на постоянный множитель \(1/4\).
Введем дополнительные доли
$$x_0=1-x,\qquad y_0=1-y.$$
Этих четырех чисел достаточно, чтобы полностью описать нормированную геометрию. Каждое допустимое относительное расположение дает медиану трех кандидатных площадей, а итоговое ядро получается усреднением по шести равновероятным конфигурациям.
Для любого тройного набора \((a,b,c)\) медиану можно записать без сортировки:
$$\operatorname{med}(a,b,c)=a+b+c-\min(a,b,c)-\max(a,b,c).$$
Именно этой формулой пользуется реализация. Она напрямую возвращает средний по величине элемент тройки.
Из нормированных долей сторон получаются шесть слагаемых
$$\begin{aligned} T_1(x,y)&=\operatorname{med}(xy,\ x_0y_0,\ 1),\\ T_2(x,y)&=\operatorname{med}(xy,\ x_0,\ y_0),\\ T_3(x,y)&=\operatorname{med}(xy_0,\ x_0y,\ 1),\\ T_4(x,y)&=\operatorname{med}(xy_0,\ x_0,\ y),\\ T_5(x,y)&=\operatorname{med}(x,\ x_0y,\ y_0),\\ T_6(x,y)&=\operatorname{med}(x,\ x_0y_0,\ y). \end{aligned}$$
Нормированное ядро равно их среднему:
$$M(x,y)=\frac{T_1(x,y)+T_2(x,y)+T_3(x,y)+T_4(x,y)+T_5(x,y)+T_6(x,y)}{6}.$$
Это и есть центральная математическая часть решения. После построения \(M(x,y)\) остается только аккуратно вычислить его интеграл.
Замена \(x\) на \(1-x\), замена \(y\) на \(1-y\) или перестановка \(x\) и \(y\) лишь переупорядочивает шесть троек выше. Следовательно,
$$M(x,y)=M(1-x,y)=M(x,1-y)=M(y,x).$$
Эти тождества важны по двум причинам. Во-первых, они подтверждают правильную геометрическую симметрию усредненного ядра. Во-вторых, они позволяют вычислять двойную квадратуру в симметричной форме по индексам узлов.
Нормированный средний вклад задается формулой
$$J=\int_0^1\int_0^1 M(x,y)\,dx\,dy.$$
После геометрической нормировки исходная ожидаемая площадь получается умножением на масштабный множитель, не зависящий от переменных-отношений. В реализованном выводе этот множитель равен \(1/4\), поэтому
$$E=\frac{J}{4}.$$
Тем самым вся вычислительная задача сводится к высокоточному вычислению \(J\).
Пусть \((\xi_i,w_i)_{i=1}^n\) — узлы и веса \(n\)-точечной квадратуры Гаусса-Лежандра на \([0,1]\). Тогда
$$J_n=\sum_{i=1}^{n}\sum_{j=1}^{n} w_i w_j M(\xi_i,\xi_j)$$
дает приближение к \(J\). Поскольку ядро симметрично по аргументам, реализации переписывают сумму так:
$$J_n=\sum_{i=1}^{n} w_i^2 M(\xi_i,\xi_i)+2\sum_{1\le i\lt j\le n} w_i w_j M(\xi_i,\xi_j).$$
Правило квадратуры остается тем же самым, но число вычислений вне диагонали почти уменьшается вдвое.
Ядро гладко внутри областей, разделенных линиями переключения медианы, поэтому глобальная ошибка квадратуры ведет себя как у кусочно-гладкого интеграла, а не как у полностью аналитической функции. Реализация моделирует главный член ошибки в виде
$$E_n=E+\frac{C}{n^2}+O\left(\frac{1}{n^4}\right).$$
Если выполнить расчет также для \(2n\) узлов, то получаем
$$E_{2n}=E+\frac{C}{4n^2}+O\left(\frac{1}{n^4}\right).$$
Исключая неизвестную константу \(C\), приходим к формуле
$$E_{\text{rich}}=E_{2n}+\frac{E_{2n}-E_n}{3}.$$
Именно это улучшенное по Ричардсону значение и выводится как окончательный ответ.
Здесь \(x_0=1\) и \(y_0=\frac{3}{4}\). Шесть медианных членов равны
$$\begin{aligned} T_1&=\operatorname{med}\left(0,\frac{3}{4},1\right)=\frac{3}{4},\\ T_2&=\operatorname{med}\left(0,1,\frac{3}{4}\right)=\frac{3}{4},\\ T_3&=\operatorname{med}\left(0,\frac{1}{4},1\right)=\frac{1}{4},\\ T_4&=\operatorname{med}\left(0,1,\frac{1}{4}\right)=\frac{1}{4},\\ T_5&=\operatorname{med}\left(0,\frac{1}{4},\frac{3}{4}\right)=\frac{1}{4},\\ T_6&=\operatorname{med}\left(0,\frac{3}{4},\frac{1}{4}\right)=\frac{1}{4}. \end{aligned}$$
Следовательно,
$$M\left(0,\frac{1}{4}\right)=\frac{\frac{3}{4}+\frac{3}{4}+\frac{1}{4}+\frac{1}{4}+\frac{1}{4}+\frac{1}{4}}{6}=\frac{5}{12},$$
и это одно из контрольных значений, проверяемых реализацией.
Реализации на C++, Python и Java используют один и тот же численный план. Сначала они вычисляют шесть медианных выражений для заданной пары \((x,y)\), затем строят узлы и веса Гаусса-Лежандра на \([0,1]\) через корни полиномов Лежандра, после чего накапливают симметричную двойную сумму для двух разрешений, \(n\) и \(2n\).
Каждое приближение интеграла делится на \(4\), затем два результата объединяются с помощью экстраполяции Ричардсона. Реализации на C++ и Java распараллеливают внешний цикл по строкам квадратуры, а реализация на Python передает работу скомпилированному численному решателю и возвращает разобранное итоговое число.
Перед выводом ответа выполняются проверки фиксированных значений ядра, симметрий и эталонных результатов квадратуры для умеренных порядков. Эти проверки страхуют одновременно от алгебраических ошибок в ядре и от численных ошибок при генерации квадратурных узлов и весов.
Для порядка \(n\) построение узлов и весов Гаусса-Лежандра требует в сумме \(O(n^2)\) арифметических операций, потому что каждая корневая итерация использует рекуррентное вычисление полинома степени \(n\), а самих корней \(O(n)\). Основная стоимость приходится на двойную квадратуру: она требует \(O(n^2)\) вычислений ядра и \(O(n)\) памяти для массивов узлов и весов. Поскольку сумма разбивается по строкам, фактическое время работы хорошо уменьшается на многоядерных системах.
تحسب التطبيقات القيمة المتوقعة لمساحة وسيطية تنشأ من بناء عشوائي يعتمد على مستطيلات. بعد تطبيع فجوتين أفقيتين متكاملتين وفجوتين رأسيتين متكاملتين، لا تبقى الهندسة معتمدة إلا على نسبتين \(x,y\in[0,1]\). وعندها تصبح الكمية المطلوبة تكاملاً ثنائيًا لنواة مطبعة، ثم يعاد تحجيمها بالعامل الثابت \(1/4\).
لنعرّف النسبتين المكملتين
$$x_0=1-x,\qquad y_0=1-y.$$
الهندسة المطبعة تتحدد بالكامل بهذه القيم الأربع. كل ترتيب نسبي مسموح يساهم بوسيط ثلاث مساحات مرشحة، ثم تؤخذ النواة النهائية على أنها متوسط ستة ترتيبات متساوية الوزن.
لأي ثلاثية \((a,b,c)\)، يمكن كتابة الوسيط من دون فرز كما يلي:
$$\operatorname{med}(a,b,c)=a+b+c-\min(a,b,c)-\max(a,b,c).$$
تستخدم التطبيقات هذه الهوية مباشرة، لأنها تعطي القيمة الوسطى بين الأعداد الثلاثة من غير الحاجة إلى خطوة ترتيب مستقلة.
انطلاقًا من نسب الأضلاع المطبعة نحصل على حدود الوسيط الستة:
$$\begin{aligned} T_1(x,y)&=\operatorname{med}(xy,\ x_0y_0,\ 1),\\ T_2(x,y)&=\operatorname{med}(xy,\ x_0,\ y_0),\\ T_3(x,y)&=\operatorname{med}(xy_0,\ x_0y,\ 1),\\ T_4(x,y)&=\operatorname{med}(xy_0,\ x_0,\ y),\\ T_5(x,y)&=\operatorname{med}(x,\ x_0y,\ y_0),\\ T_6(x,y)&=\operatorname{med}(x,\ x_0y_0,\ y). \end{aligned}$$
ومن ثم تكون النواة المطبعة هي متوسطها:
$$M(x,y)=\frac{T_1(x,y)+T_2(x,y)+T_3(x,y)+T_4(x,y)+T_5(x,y)+T_6(x,y)}{6}.$$
هذه هي اللبنة الرياضية الأساسية في الحل. فبمجرد بناء \(M(x,y)\)، يتحول ما تبقى إلى مسألة تكامل عددي عالي الدقة.
استبدال \(x\) بـ \(1-x\)، أو \(y\) بـ \(1-y\)، أو تبديل \(x\) و\(y\)، لا يفعل إلا إعادة ترتيب الثلاثيات الست السابقة. لذلك نحصل على
$$M(x,y)=M(1-x,y)=M(x,1-y)=M(y,x).$$
هذه العلاقات مهمة لسببين. أولًا، إنها تؤكد أن متوسط الحدود الستة يحافظ على التناظر الهندسي المتوقع. ثانيًا، إنها تسمح بإعادة تنظيم التكامل الثنائي بحيث نحسب الجزء العلوي فقط ثم نستفيد من التناظر.
المساهمة المتوسطة بعد التطبيع هي
$$J=\int_0^1\int_0^1 M(x,y)\,dx\,dy.$$
بعد التطبيع الهندسي، تستعاد المساحة المتوقعة الأصلية بضرب هذا المقدار في عامل قياس مستقل عن متغيرات النسبة. وفي الاشتقاق الذي تطبقه الشيفرة يكون هذا العامل مساويًا لـ \(1/4\)، ولذلك
$$E=\frac{J}{4}.$$
وبذلك تصبح المهمة الحسابية كلها هي إيجاد \(J\) بدقة كبيرة جدًا.
لتكن \((\xi_i,w_i)_{i=1}^n\) عقد وأوزان Gauss-Legendre من الرتبة \(n\) على الفترة \([0,1]\). عندئذ يكون
$$J_n=\sum_{i=1}^{n}\sum_{j=1}^{n} w_i w_j M(\xi_i,\xi_j)$$
تقريبًا عالي الدقة لـ \(J\). ولأن النواة متناظرة في متغيريها، تعيد التطبيقات كتابة المجموع على الصورة
$$J_n=\sum_{i=1}^{n} w_i^2 M(\xi_i,\xi_i)+2\sum_{1\le i\lt j\le n} w_i w_j M(\xi_i,\xi_j).$$
هذا يحافظ على نفس قاعدة التكامل، لكنه يقلل تقريبًا إلى النصف عدد تقييمات النواة خارج القطر.
النواة ملساء داخل مناطق تفصلها حدود يتبدل عندها اختيار الوسيط، ولذلك فإن خطأ التكامل العددي يتصرف كما في التكاملات الملساء على أجزاء، لا كما في دالة تحليلية تمامًا. ولهذا تفترض التطبيقات أن الحد الرئيسي للخطأ يأخذ الصورة
$$E_n=E+\frac{C}{n^2}+O\left(\frac{1}{n^4}\right).$$
وبحساب التقريب مرة عند \(n\) ومرة عند \(2n\) نحصل على
$$E_{2n}=E+\frac{C}{4n^2}+O\left(\frac{1}{n^4}\right).$$
بحذف الثابت المجهول \(C\) ينتج
$$E_{\text{rich}}=E_{2n}+\frac{E_{2n}-E_n}{3}.$$
وهذه هي القيمة المصححة بطريقة Richardson والتي تُطبع في النهاية.
هنا لدينا \(x_0=1\) و\(y_0=\frac{3}{4}\). وعندها تصبح حدود الوسيط الستة
$$\begin{aligned} T_1&=\operatorname{med}\left(0,\frac{3}{4},1\right)=\frac{3}{4},\\ T_2&=\operatorname{med}\left(0,1,\frac{3}{4}\right)=\frac{3}{4},\\ T_3&=\operatorname{med}\left(0,\frac{1}{4},1\right)=\frac{1}{4},\\ T_4&=\operatorname{med}\left(0,1,\frac{1}{4}\right)=\frac{1}{4},\\ T_5&=\operatorname{med}\left(0,\frac{1}{4},\frac{3}{4}\right)=\frac{1}{4},\\ T_6&=\operatorname{med}\left(0,\frac{3}{4},\frac{1}{4}\right)=\frac{1}{4}. \end{aligned}$$
إذًا
$$M\left(0,\frac{1}{4}\right)=\frac{\frac{3}{4}+\frac{3}{4}+\frac{1}{4}+\frac{1}{4}+\frac{1}{4}+\frac{1}{4}}{6}=\frac{5}{12},$$
وهي إحدى قيم التحقق التي تؤكدها التطبيقات.
تتبع تطبيقات C++ وPython وJava الخطة العددية نفسها. فهي تبدأ بحساب حدود الوسيط الستة لأي زوج معطى \((x,y)\)، ثم تبني عقد وأوزان Gauss-Legendre على \([0,1]\) انطلاقًا من جذور كثيرات حدود Legendre، وبعد ذلك تجمع الصيغة الثنائية المتناظرة لرتبتين مختلفتين هما \(n\) و\(2n\).
يُقسم كل تقريب للتكامل على \(4\)، ثم يُدمج التقريبان بواسطة استقراء Richardson. وتقوم تطبيقتا C++ وJava بموازاة الحلقة الخارجية على صفوف التكامل العددي، بينما يفوض تطبيق Python التنفيذ إلى المحرك العددي المترجم ثم يعيد القيمة النهائية بعد استخراجها من المخرجات.
وقبل إخراج الجواب، يتم التحقق من قيم ثابتة للنواة، ومن هويات التناظر، ومن نتائج مرجعية للتكامل عند رتب متوسطة. هذه الاختبارات تحمي من الأخطاء الجبرية في النواة ومن الأخطاء العددية في مولد العقد والأوزان معًا.
لرتبة \(n\)، يتطلب توليد عقد وأوزان Gauss-Legendre عددًا إجماليًا مقداره \(O(n^2)\) من العمليات الحسابية، لأن كل جذر يُحسب عبر علاقة رجعية من الدرجة \(n\)، وعدد الجذور نفسه يساوي \(O(n)\). أما الكلفة المسيطرة فهي كلفة التكامل الثنائي نفسه، إذ يحتاج إلى \(O(n^2)\) من تقييمات النواة وإلى \(O(n)\) من الذاكرة لتخزين مصفوفتَي العقد والأوزان. وبما أن الجمع موزع على صفوف مستقلة، فإن الزمن الفعلي يستفيد مباشرة من المعالجات متعددة الأنوية.