Place the right triangle at \(C=(0,0)\), \(A=(40,0)\), and \(B=(0,30)\), so the legs have lengths \(40\) and \(30\) and the hypotenuse is the side \(AB\) of length \(50\). An interior starting point \(P=(x,y)\) is chosen uniformly from the triangle, and an initial direction is chosen uniformly from \([0,2\pi)\). The ray travels straight until it first meets the boundary.
The task is to find the probability that the exit side is the hypotenuse \(AB\), rounded to \(10\) decimal places. Because the requested precision is much tighter than a simple Monte Carlo simulation would reliably provide, the solution turns the probability into a deterministic area integral and evaluates that integral numerically with high-order quadrature.
The geometric core is simple: for a fixed interior point, the directions that reach the hypotenuse form exactly one angular interval.
The triangle is
$$T=\left\{(x,y): x\ge 0,\ y\ge 0,\ \frac{x}{40}+\frac{y}{30}\le 1\right\}.$$
Its area is
$$\Delta=\frac{30\cdot 40}{2}=600.$$
For any interior point \(P=(x,y)\), the two endpoints of the target side are \(A=(40,0)\) and \(B=(0,30)\). Everything reduces to understanding the angle subtended by the segment \(AB\) as seen from \(P\).
Fix \(P\in T\). The directions that eventually hit the side \(AB\) are precisely the rays that lie between the rays \(PA\) and \(PB\). Their total angular measure is
$$\theta(P)=\angle APB.$$
Because the initial direction is uniform on the full circle, the conditional probability is
$$\mathbb{P}(AB\mid P)=\frac{\theta(P)}{2\pi}.$$
Directions that hit a vertex have measure zero, so they do not affect the average.
Write the vectors from \(P\) to the endpoints of the hypotenuse as
$$a=A-P=(40-x,-y),\qquad b=B-P=(-x,30-y).$$
The angle between two vectors can be recovered from their oriented area and dot product via
$$\theta(P)=\operatorname{atan2}\!\left(\left\lvert a_x b_y-a_y b_x\right\rvert,\ a_x b_x+a_y b_y\right).$$
This is exactly the form used by the implementations because it stays numerically stable when the angle is very small or very close to \(\pi\). In this triangle, the numerator also has a geometric meaning:
$$\left\lvert a_x b_y-a_y b_x\right\rvert=1200-30x-40y,$$
which is twice the area of triangle \(APB\) and is positive for every interior point.
Now average the conditional probability over the uniformly distributed point \(P\):
$$p=\frac{1}{\Delta}\iint_T \frac{\theta(P)}{2\pi}\,dA=\frac{1}{2\pi\Delta}\iint_T \theta(x,y)\,dA.$$
Since \(\Delta=600\), this becomes
$$p=\frac{1}{1200\pi}\iint_T \theta(x,y)\,dA.$$
So the problem is reduced to evaluating a two-dimensional integral over the triangle.
The numerical integration becomes much cleaner after the substitution
$$x=40u,\qquad y=30(1-u)v,\qquad (u,v)\in[0,1]^2.$$
This parametrization sweeps the triangle with vertical segments: when \(u=0\) we are on the left side, and when \(u=1\) we collapse to the vertex \(A\). The Jacobian determinant is
$$\left\lvert\frac{\partial(x,y)}{\partial(u,v)}\right\rvert=1200(1-u).$$
Therefore
$$p=\frac{1}{1200\pi}\int_0^1\int_0^1 \theta\!\left(40u,\,30(1-u)v\right)\,1200(1-u)\,dv\,du.$$
The denominator \(1200\pi\) that appears in the code comes directly from this formula.
Take \(P=(10,10)\). Then
$$a=(30,-10),\qquad b=(-10,20).$$
Compute
$$\left\lvert a_x b_y-a_y b_x\right\rvert=\left\lvert 30\cdot 20-(-10)(-10)\right\rvert=500,$$
$$a_x b_x+a_y b_y=30(-10)+(-10)\cdot 20=-500.$$
Hence
$$\theta(P)=\operatorname{atan2}(500,-500)=\frac{3\pi}{4},$$
so the conditional probability at this point is
$$\mathbb{P}(AB\mid P)=\frac{3\pi/4}{2\pi}=\frac{3}{8}.$$
This is only a local value; the final answer is obtained by averaging \(\theta(P)\) over all interior points.
After transforming the domain to \([0,1]^2\), the integral is approximated with a tensor-product Gauss-Legendre rule. If \((u_i,w_i)\) are one-dimensional nodes and weights on \([0,1]\), then
$$p\approx \frac{1}{1200\pi}\sum_{i=1}^n\sum_{j=1}^n w_i w_j\,\theta\!\left(40u_i,\,30(1-u_i)u_j\right)\,1200(1-u_i).$$
Using a large order such as \(n=1024\) gives the required accuracy for the printed \(10\)-decimal result.
The C++, Python, and Java implementations all begin by constructing Gauss-Legendre nodes and weights on \([0,1]\). They first work on the standard interval \([-1,1]\), use symmetry so only half of the roots need to be found explicitly, and refine the Legendre roots with Newton iteration. The Legendre polynomial values and derivatives are obtained from the standard recurrence, and the nodes and weights are then rescaled from \([-1,1]\) to \([0,1]\).
Once the one-dimensional rule is available, the implementation forms the two-dimensional tensor product. For each outer quadrature node it computes the corresponding \(x\)-coordinate and the Jacobian factor \(1200(1-u)\). For each inner node it computes the matching \(y\)-coordinate, forms the two vectors from the sample point to the endpoints of the hypotenuse, evaluates the angle with the stable \(\operatorname{atan2}\) formula, and adds the weighted contribution to the running integral.
After the double sum is complete, the implementation divides by \(1200\pi\) and formats the probability to \(10\) decimal places. The C++ implementation additionally compares the \(512\)-point and \(1024\)-point quadrature results as a numerical sanity check, while the Python and Java implementations directly evaluate the \(1024\times 1024\) rule.
For quadrature order \(n\), generating the one-dimensional Gauss-Legendre rule costs \(O(n^2)\) arithmetic overall because each root refinement evaluates degree-\(n\) Legendre recurrences. The dominant step is the tensor-product integration, which performs \(n^2\) angle evaluations, so the total running time is \(O(n^2)\). Memory usage is \(O(n)\), since only the one-dimensional nodes and weights plus a few scalars are stored.
Wir legen das rechtwinklige Dreieck in die Koordinatenebene mit \(C=(0,0)\), \(A=(40,0)\) und \(B=(0,30)\). Die Katheten haben also die Längen \(40\) und \(30\), und die Hypotenuse ist die Seite \(AB\) mit Länge \(50\). Ein Startpunkt \(P=(x,y)\) wird gleichverteilt aus dem Inneren des Dreiecks gewählt, und die Bewegungsrichtung wird gleichverteilt aus \([0,2\pi)\) gezogen.
Gesucht ist die Wahrscheinlichkeit, dass der Strahl das Dreieck zuerst über die Hypotenuse \(AB\) verlässt, gerundet auf \(10\) Nachkommastellen. Eine reine Zufallssimulation wäre für diese Genauigkeit unzuverlässig, daher wird die Wahrscheinlichkeit als Flächenintegral formuliert und anschließend mit hochgenauer Quadratur ausgewertet.
Der entscheidende geometrische Punkt ist: Für einen festen inneren Punkt bilden die günstigen Richtungen genau ein zusammenhängendes Winkelintervall.
Das Dreieck ist
$$T=\left\{(x,y): x\ge 0,\ y\ge 0,\ \frac{x}{40}+\frac{y}{30}\le 1\right\}.$$
Sein Flächeninhalt ist
$$\Delta=\frac{30\cdot 40}{2}=600.$$
Für jeden inneren Punkt \(P=(x,y)\) sind \(A=(40,0)\) und \(B=(0,30)\) die Endpunkte der Zielseite. Damit hängt alles vom Winkel ab, unter dem die Strecke \(AB\) von \(P\) aus gesehen wird.
Fixiere \(P\in T\). Genau diejenigen Richtungen treffen die Seite \(AB\), die zwischen den Strahlen \(PA\) und \(PB\) liegen. Ihr Gesamtwinkelmaß ist
$$\theta(P)=\angle APB.$$
Da die Anfangsrichtung auf dem Vollkreis gleichverteilt ist, gilt
$$\mathbb{P}(AB\mid P)=\frac{\theta(P)}{2\pi}.$$
Richtungen, die exakt einen Eckpunkt treffen, bilden nur eine Menge vom Maß null und beeinflussen den Mittelwert daher nicht.
Schreibe die Vektoren von \(P\) zu den Endpunkten der Hypotenuse als
$$a=A-P=(40-x,-y),\qquad b=B-P=(-x,30-y).$$
Der Winkel zwischen zwei Vektoren lässt sich robust aus Flächeninhalt und Skalarprodukt gewinnen:
$$\theta(P)=\operatorname{atan2}\!\left(\left\lvert a_x b_y-a_y b_x\right\rvert,\ a_x b_x+a_y b_y\right).$$
Genau diese Form verwenden die Implementierungen, weil sie auch bei sehr kleinen oder sehr großen Winkeln stabil bleibt. Im vorliegenden Dreieck gilt außerdem
$$\left\lvert a_x b_y-a_y b_x\right\rvert=1200-30x-40y,$$
also gerade das Doppelte des Flächeninhalts von \(APB\), und dieser Ausdruck ist für jeden inneren Punkt positiv.
Nun mitteln wir die bedingte Wahrscheinlichkeit über den gleichverteilten Punkt \(P\):
$$p=\frac{1}{\Delta}\iint_T \frac{\theta(P)}{2\pi}\,dA=\frac{1}{2\pi\Delta}\iint_T \theta(x,y)\,dA.$$
Mit \(\Delta=600\) wird daraus
$$p=\frac{1}{1200\pi}\iint_T \theta(x,y)\,dA.$$
Damit ist die Aufgabe auf ein zweidimensionales Integral über das Dreieck reduziert.
Für die numerische Integration ist die Substitution
$$x=40u,\qquad y=30(1-u)v,\qquad (u,v)\in[0,1]^2$$
besonders praktisch. Sie durchläuft das Dreieck mit vertikalen Segmenten: Bei \(u=0\) liegt man auf der linken Seite, bei \(u=1\) kollabiert alles im Eckpunkt \(A\). Die Jacobi-Determinante ist
$$\left\lvert\frac{\partial(x,y)}{\partial(u,v)}\right\rvert=1200(1-u).$$
Daher folgt
$$p=\frac{1}{1200\pi}\int_0^1\int_0^1 \theta\!\left(40u,\,30(1-u)v\right)\,1200(1-u)\,dv\,du.$$
Genau daraus stammt der Faktor \(1200\pi\), durch den am Ende dividiert wird.
Wähle \(P=(10,10)\). Dann sind
$$a=(30,-10),\qquad b=(-10,20).$$
Es gilt
$$\left\lvert a_x b_y-a_y b_x\right\rvert=\left\lvert 30\cdot 20-(-10)(-10)\right\rvert=500,$$
$$a_x b_x+a_y b_y=30(-10)+(-10)\cdot 20=-500.$$
Somit
$$\theta(P)=\operatorname{atan2}(500,-500)=\frac{3\pi}{4},$$
und die bedingte Wahrscheinlichkeit an diesem Punkt ist
$$\mathbb{P}(AB\mid P)=\frac{3\pi/4}{2\pi}=\frac{3}{8}.$$
Der Gesamtwert entsteht erst durch das Flächenmittel über alle inneren Punkte.
Nach der Transformation auf \([0,1]^2\) wird das Integral mit einer Tensorprodukt-Gauß-Legendre-Regel angenähert. Sind \((u_i,w_i)\) eindimensionale Stützstellen und Gewichte auf \([0,1]\), dann gilt
$$p\approx \frac{1}{1200\pi}\sum_{i=1}^n\sum_{j=1}^n w_i w_j\,\theta\!\left(40u_i,\,30(1-u_i)u_j\right)\,1200(1-u_i).$$
Mit einer hohen Ordnung wie \(n=1024\) wird die gewünschte Genauigkeit für die Ausgabe auf \(10\) Nachkommastellen erreicht.
Die C++-, Python- und Java-Implementierungen erzeugen zunächst Gauß-Legendre-Stützstellen und -Gewichte auf \([0,1]\). Dazu arbeiten sie zuerst auf \([-1,1]\), nutzen die Symmetrie der Legendre-Nullstellen, verfeinern diese mit Newton-Iteration und berechnen Polynomwerte sowie Ableitungen über die übliche Rekursion. Anschließend werden sowohl Stützstellen als auch Gewichte auf das Intervall \([0,1]\) umskaliert.
Danach wird das zweidimensionale Tensorprodukt gebildet. Für jeden äußeren Quadraturpunkt werden die zugehörige \(x\)-Koordinate und der Jacobi-Faktor \(1200(1-u)\) bestimmt. Für jeden inneren Punkt werden dann \(y\), die beiden Vektoren zu den Endpunkten der Hypotenuse, der Winkel über die stabile \(\operatorname{atan2}\)-Formel und schließlich der gewichtete Beitrag zum Integral berechnet und aufsummiert.
Nach Abschluss der Doppelsumme dividiert die Implementierung durch \(1200\pi\) und formatiert die Wahrscheinlichkeit mit \(10\) Nachkommastellen. Die C++-Implementierung vergleicht zusätzlich die Resultate der Ordnungen \(512\) und \(1024\) als numerischen Plausibilitätscheck; die Python- und Java-Implementierungen werten direkt die \(1024\times 1024\)-Regel aus.
Für Quadraturordnung \(n\) kostet die Erzeugung der eindimensionalen Gauß-Legendre-Regel insgesamt \(O(n^2)\) Rechenoperationen, weil jede Nullstellensuche Legendre-Rekursionen vom Grad \(n\) auswertet. Der dominierende Teil ist jedoch die Tensorprodukt-Integration mit \(n^2\) Winkelberechnungen. Insgesamt ergibt sich daher eine Laufzeit von \(O(n^2)\) und ein Speicherbedarf von \(O(n)\), da nur die eindimensionalen Stützstellen, Gewichte und einige Skalare gespeichert werden.
Dik üçgeni \(C=(0,0)\), \(A=(40,0)\) ve \(B=(0,30)\) olacak şekilde yerleştirelim. Böylece dik kenarlar \(40\) ve \(30\), hipotenüs ise uzunluğu \(50\) olan \(AB\) kenarıdır. Başlangıç noktası \(P=(x,y)\) üçgenin içinden düzgün dağılımla seçiliyor ve hareket yönü de \([0,2\pi)\) aralığında düzgün rastgele seçiliyor.
İstenen şey, ışının sınırı ilk kestiği kenarın hipotenüs \(AB\) olma olasılığıdır; sonuç \(10\) ondalık basamağa yuvarlanır. Bu hassasiyette doğrudan Monte Carlo yaklaşımı yetersiz kalacağından çözüm, olasılığı deterministik bir alan integraline dönüştürür ve bunu yüksek dereceli quadrature ile hesaplar.
Temel geometrik gözlem şudur: Sabit bir iç nokta için hipotenüse giden yönler tek bir sürekli açı aralığı oluşturur.
Üçgen bölgesi
$$T=\left\{(x,y): x\ge 0,\ y\ge 0,\ \frac{x}{40}+\frac{y}{30}\le 1\right\}$$
şeklindedir. Alanı
$$\Delta=\frac{30\cdot 40}{2}=600$$
olur. Her iç nokta \(P=(x,y)\) için hedef kenarın uçları \(A=(40,0)\) ve \(B=(0,30)\) olduğundan, mesele \(AB\) doğrusunun \(P\) noktasından gördüğü açıyı hesaplamaya indirgenir.
\(P\in T\) sabit olsun. Hipotenüs \(AB\)'ye ulaşan yönler tam olarak \(PA\) ve \(PB\) ışınları arasında kalan yönlerdir. Bu yön kümesinin açısal ölçüsü
$$\theta(P)=\angle APB$$
olur. Başlangıç yönü tam çember üzerinde düzgün dağıldığı için
$$\mathbb{P}(AB\mid P)=\frac{\theta(P)}{2\pi}$$
elde edilir. Bir köşeye tam isabet eden yönler ölçü sıfır olduğundan ortalamayı etkilemez.
Hipotenüs uçlarına giden vektörleri
$$a=A-P=(40-x,-y),\qquad b=B-P=(-x,30-y)$$
olarak yazalım. İki vektör arasındaki açı şu kararlı formülle hesaplanır:
$$\theta(P)=\operatorname{atan2}\!\left(\left\lvert a_x b_y-a_y b_x\right\rvert,\ a_x b_x+a_y b_y\right).$$
Uygulamada tam olarak bu ifade kullanılır; çünkü açı çok küçükken ya da \(\pi\)'ye yaklaşırken bile iyi davranır. Ayrıca bu üçgende pay kısmı
$$\left\lvert a_x b_y-a_y b_x\right\rvert=1200-30x-40y$$
olur; bu da \(APB\) üçgeninin alanının iki katıdır ve tüm iç noktalarda pozitiftir.
Şimdi koşullu olasılığı düzgün dağılımlı \(P\) üzerinde ortalayalım:
$$p=\frac{1}{\Delta}\iint_T \frac{\theta(P)}{2\pi}\,dA=\frac{1}{2\pi\Delta}\iint_T \theta(x,y)\,dA.$$
\(\Delta=600\) olduğundan
$$p=\frac{1}{1200\pi}\iint_T \theta(x,y)\,dA$$
elde edilir. Böylece problem üçgen üzerindeki iki boyutlu bir integrale dönüşür.
Sayısal integrasyon için en uygun değişken dönüşümü
$$x=40u,\qquad y=30(1-u)v,\qquad (u,v)\in[0,1]^2$$
şeklindedir. Bu parametrizasyon üçgeni düşey kesitlerle tarar: \(u=0\) iken sol kenardayız, \(u=1\) iken \(A\) köşesine çökeriz. Jacobian determinantı
$$\left\lvert\frac{\partial(x,y)}{\partial(u,v)}\right\rvert=1200(1-u)$$
olur. Dolayısıyla
$$p=\frac{1}{1200\pi}\int_0^1\int_0^1 \theta\!\left(40u,\,30(1-u)v\right)\,1200(1-u)\,dv\,du.$$
Koddaki \(1200\pi\) paydası doğrudan bu formülden gelir.
\(P=(10,10)\) noktasını alalım. Bu durumda
$$a=(30,-10),\qquad b=(-10,20).$$
Şimdi
$$\left\lvert a_x b_y-a_y b_x\right\rvert=\left\lvert 30\cdot 20-(-10)(-10)\right\rvert=500,$$
$$a_x b_x+a_y b_y=30(-10)+(-10)\cdot 20=-500$$
bulunur. Buradan
$$\theta(P)=\operatorname{atan2}(500,-500)=\frac{3\pi}{4}$$
ve dolayısıyla
$$\mathbb{P}(AB\mid P)=\frac{3\pi/4}{2\pi}=\frac{3}{8}$$
elde edilir. Bu yalnızca tek bir noktanın değeridir; nihai olasılık tüm iç noktalardaki ortalamadır.
Bölge \([0,1]^2\)'ye taşındıktan sonra integral tensör çarpımı biçiminde Gauss-Legendre quadrature ile hesaplanır. Eğer \((u_i,w_i)\) \([0,1]\) üzerindeki tek boyutlu düğüm ve ağırlıklarsa
$$p\approx \frac{1}{1200\pi}\sum_{i=1}^n\sum_{j=1}^n w_i w_j\,\theta\!\left(40u_i,\,30(1-u_i)u_j\right)\,1200(1-u_i).$$
\(n=1024\) gibi yüksek bir derece, yazdırılan \(10\) ondalık basamak için gereken doğruluğu sağlar.
C++, Python ve Java implementasyonları önce \([0,1]\) aralığı üzerinde Gauss-Legendre düğüm ve ağırlıklarını üretir. Bunun için önce standart \([-1,1]\) aralığında çalışırlar, Legendre köklerinin simetrisinden yararlanırlar, kökleri Newton iterasyonu ile keskinleştirirler ve polinom ile türev değerlerini klasik üç terimli bağıntı üzerinden hesaplarlar. Sonra hem düğümler hem de ağırlıklar \([0,1]\) aralığına yeniden ölçeklenir.
Ardından iki boyutlu tensör ızgarası kurulur. Dış döngüde her quadrature düğümü için karşılık gelen \(x\) koordinatı ve Jacobian çarpanı \(1200(1-u)\) hesaplanır. İç döngüde \(y\) koordinatı bulunur, örnek noktasından hipotenüs uçlarına giden iki vektör oluşturulur, açı kararlı \(\operatorname{atan2}\) formülüyle hesaplanır ve ağırlıklı katkı toplama eklenir.
Çift toplam tamamlandıktan sonra implementasyon sonuç değeri \(1200\pi\)'ye böler ve olasılığı \(10\) ondalık basamakla yazar. C++ implementasyonu ayrıca \(512\) ve \(1024\) dereceli quadrature sonuçlarını karşılaştırarak küçük bir sayısal sağlamlık kontrolü yapar; Python ve Java implementasyonları doğrudan \(1024\times 1024\) kuralını uygular.
Quadrature derecesi \(n\) için tek boyutlu Gauss-Legendre kuralını üretmek toplamda \(O(n^2)\) aritmetik işlem gerektirir; çünkü her kök iyileştirmesi derece \(n\) Legendre bağıntılarını değerlendirir. Baskın maliyet ise \(n^2\) adet açı hesabı içeren iki boyutlu tensör integrasyonudur. Bu nedenle toplam çalışma süresi \(O(n^2)\), bellek kullanımı ise yalnızca tek boyutlu düğüm ve ağırlık dizileri tutulduğu için \(O(n)\) olur.
Colocamos el triángulo rectángulo en \(C=(0,0)\), \(A=(40,0)\) y \(B=(0,30)\). Así, los catetos miden \(40\) y \(30\), y la hipotenusa es el lado \(AB\) de longitud \(50\). El punto inicial \(P=(x,y)\) se elige uniformemente en el interior del triángulo y la dirección inicial también se elige uniformemente en \([0,2\pi)\).
Hay que calcular la probabilidad de que el primer lado alcanzado por la trayectoria sea la hipotenusa \(AB\), redondeada a \(10\) decimales. Una simulación aleatoria simple no da esa precisión con comodidad, por lo que la solución convierte el problema en una integral de área y la evalúa mediante cuadratura numérica de orden alto.
La idea geométrica central es que, para un punto interior fijo, las direcciones favorables forman un único intervalo angular continuo.
La región triangular es
$$T=\left\{(x,y): x\ge 0,\ y\ge 0,\ \frac{x}{40}+\frac{y}{30}\le 1\right\}.$$
Su área es
$$\Delta=\frac{30\cdot 40}{2}=600.$$
Para cualquier punto interior \(P=(x,y)\), los extremos del lado objetivo son \(A=(40,0)\) y \(B=(0,30)\). Por tanto, todo se reduce al ángulo bajo el cual el segmento \(AB\) es visto desde \(P\).
Fijemos \(P\in T\). Las direcciones que terminan en el lado \(AB\) son exactamente las que quedan entre los rayos \(PA\) y \(PB\). La medida angular de ese conjunto es
$$\theta(P)=\angle APB.$$
Como la dirección inicial es uniforme en la circunferencia completa, se obtiene
$$\mathbb{P}(AB\mid P)=\frac{\theta(P)}{2\pi}.$$
Las direcciones que pasan exactamente por un vértice tienen medida nula, así que no alteran el promedio final.
Escribimos los vectores desde \(P\) hasta los extremos de la hipotenusa:
$$a=A-P=(40-x,-y),\qquad b=B-P=(-x,30-y).$$
El ángulo entre dos vectores se recupera de forma robusta mediante
$$\theta(P)=\operatorname{atan2}\!\left(\left\lvert a_x b_y-a_y b_x\right\rvert,\ a_x b_x+a_y b_y\right).$$
Esa es exactamente la forma usada en la implementación, porque sigue siendo estable cuando el ángulo es muy pequeño o muy cercano a \(\pi\). En este problema, además, el numerador se simplifica a
$$\left\lvert a_x b_y-a_y b_x\right\rvert=1200-30x-40y,$$
que es el doble del área del triángulo \(APB\) y resulta positivo para todo punto interior.
Ahora promediamos la probabilidad condicional respecto al punto uniforme \(P\):
$$p=\frac{1}{\Delta}\iint_T \frac{\theta(P)}{2\pi}\,dA=\frac{1}{2\pi\Delta}\iint_T \theta(x,y)\,dA.$$
Como \(\Delta=600\), queda
$$p=\frac{1}{1200\pi}\iint_T \theta(x,y)\,dA.$$
Así, el problema se transforma en una integral bidimensional sobre el triángulo.
La sustitución
$$x=40u,\qquad y=30(1-u)v,\qquad (u,v)\in[0,1]^2$$
es especialmente conveniente para integrar numéricamente. Barre el triángulo con segmentos verticales: cuando \(u=0\) estamos en el lado izquierdo y cuando \(u=1\) todo colapsa en el vértice \(A\). El determinante jacobiano es
$$\left\lvert\frac{\partial(x,y)}{\partial(u,v)}\right\rvert=1200(1-u).$$
Entonces
$$p=\frac{1}{1200\pi}\int_0^1\int_0^1 \theta\!\left(40u,\,30(1-u)v\right)\,1200(1-u)\,dv\,du.$$
De aquí sale exactamente el denominador \(1200\pi\) que aparece al final del cálculo.
Tomemos \(P=(10,10)\). Entonces
$$a=(30,-10),\qquad b=(-10,20).$$
Calculamos
$$\left\lvert a_x b_y-a_y b_x\right\rvert=\left\lvert 30\cdot 20-(-10)(-10)\right\rvert=500,$$
$$a_x b_x+a_y b_y=30(-10)+(-10)\cdot 20=-500.$$
Por tanto,
$$\theta(P)=\operatorname{atan2}(500,-500)=\frac{3\pi}{4},$$
y la probabilidad condicional es
$$\mathbb{P}(AB\mid P)=\frac{3\pi/4}{2\pi}=\frac{3}{8}.$$
Ese valor corresponde solo a un punto; la respuesta final aparece al promediar sobre todo el interior del triángulo.
Una vez que la región se ha llevado a \([0,1]^2\), la integral se aproxima mediante una regla tensorial de Gauss-Legendre. Si \((u_i,w_i)\) son nodos y pesos unidimensionales en \([0,1]\), entonces
$$p\approx \frac{1}{1200\pi}\sum_{i=1}^n\sum_{j=1}^n w_i w_j\,\theta\!\left(40u_i,\,30(1-u_i)u_j\right)\,1200(1-u_i).$$
Un orden grande, como \(n=1024\), proporciona la precisión necesaria para la salida con \(10\) decimales.
Las implementaciones en C++, Python y Java empiezan construyendo nodos y pesos de Gauss-Legendre en \([0,1]\). Primero trabajan en \([-1,1]\), aprovechan la simetría de las raíces del polinomio de Legendre, refinan esas raíces con iteración de Newton y obtienen valores del polinomio y de su derivada mediante la recurrencia estándar. Después reescalan nodos y pesos al intervalo \([0,1]\).
Con la regla unidimensional ya disponible, la implementación forma el producto tensorial bidimensional. Para cada nodo exterior calcula la coordenada \(x\) correspondiente y el factor jacobiano \(1200(1-u)\). Para cada nodo interior calcula la coordenada \(y\), construye los dos vectores desde el punto de muestra hasta los extremos de la hipotenusa, evalúa el ángulo con la fórmula estable de \(\operatorname{atan2}\) y suma la contribución ponderada al integral acumulado.
Al finalizar la suma doble, la implementación divide por \(1200\pi\) y formatea la probabilidad con \(10\) decimales. La implementación en C++ además compara los resultados de orden \(512\) y \(1024\) como verificación numérica, mientras que las implementaciones en Python y Java evalúan directamente la regla \(1024\times 1024\).
Para un orden de cuadratura \(n\), la construcción de la regla unidimensional de Gauss-Legendre cuesta \(O(n^2)\) operaciones aritméticas en total, porque cada refinamiento de raíz evalúa recurrencias de Legendre de grado \(n\). El paso dominante es la integración tensorial, que realiza \(n^2\) evaluaciones del ángulo. Por lo tanto, el tiempo total es \(O(n^2)\) y la memoria es \(O(n)\), ya que solo se almacenan los nodos y pesos unidimensionales junto con unas pocas variables auxiliares.
把直角三角形放在坐标系中，令 \(C=(0,0)\)、\(A=(40,0)\)、\(B=(0,30)\)。这样两条直角边长度分别为 \(40\) 和 \(30\)，斜边就是长度为 \(50\) 的 \(AB\)。蚂蚁的起点 \(P=(x,y)\) 在三角形内部均匀随机选取，初始前进方向也在 \([0,2\pi)\) 上均匀随机选取。
要求的是：蚂蚁沿着这条射线前进，第一次碰到边界时，恰好从斜边 \(AB\) 离开的概率，并把结果四舍五入到小数点后 \(10\) 位。为了达到这样的精度，不能依赖简单随机模拟，而是要把问题改写成一个确定性的二维积分，再用高阶数值积分稳定求值。
整个问题的关键几何事实是：对于固定的内部点，能够通向斜边的方向集合正好对应一个连续的角区间。
三角形区域可以写成
$$T=\left\{(x,y): x\ge 0,\ y\ge 0,\ \frac{x}{40}+\frac{y}{30}\le 1\right\}.$$
它的面积为
$$\Delta=\frac{30\cdot 40}{2}=600.$$
对于任意内部点 \(P=(x,y)\)，目标边的两个端点固定为 \(A=(40,0)\) 与 \(B=(0,30)\)。因此问题的核心就是：从 \(P\) 看过去，线段 \(AB\) 张开的视角到底有多大。
先固定一个内部点 \(P\in T\)。从 \(P\) 出发，最终会撞到斜边 \(AB\) 的那些方向，恰好就是位于射线 \(PA\) 与射线 \(PB\) 之间的所有方向。这个方向集合的角度大小记为
$$\theta(P)=\angle APB.$$
因为方向在整个圆周上均匀分布，所以在给定 \(P\) 的条件下，有
$$\mathbb{P}(AB\mid P)=\frac{\theta(P)}{2\pi}.$$
恰好打到顶点的方向只对应零测集，对最终平均值没有影响。
把从 \(P\) 指向斜边两个端点的向量写成
$$a=A-P=(40-x,-y),\qquad b=B-P=(-x,30-y).$$
两个向量之间的夹角可以通过叉积大小和点积一起稳定地恢复出来：
$$\theta(P)=\operatorname{atan2}\!\left(\left\lvert a_x b_y-a_y b_x\right\rvert,\ a_x b_x+a_y b_y\right).$$
实现中正是使用这个表达式，因为当角度很小或者非常接近 \(\pi\) 时，它依然比直接用反余弦更稳定。在本题里，分子还可以化简为
$$\left\lvert a_x b_y-a_y b_x\right\rvert=1200-30x-40y,$$
它恰好等于三角形 \(APB\) 面积的两倍，并且对所有内部点都为正值。
接下来把上面的条件概率对均匀分布的起点 \(P\) 做平均：
$$p=\frac{1}{\Delta}\iint_T \frac{\theta(P)}{2\pi}\,dA=\frac{1}{2\pi\Delta}\iint_T \theta(x,y)\,dA.$$
代入 \(\Delta=600\) 后得到
$$p=\frac{1}{1200\pi}\iint_T \theta(x,y)\,dA.$$
于是原题已经等价于一个定义在三角形区域上的二维积分问题。
为了更方便地做数值积分，采用变量替换
$$x=40u,\qquad y=30(1-u)v,\qquad (u,v)\in[0,1]^2.$$
这个参数化可以理解为：固定 \(u\) 以后，在一条竖直线段上用 \(v\) 从下往上扫描；当 \(u=0\) 时在左边界上，当 \(u=1\) 时整个线段缩并到顶点 \(A\)。对应的雅可比行列式为
$$\left\lvert\frac{\partial(x,y)}{\partial(u,v)}\right\rvert=1200(1-u).$$
因此积分变为
$$p=\frac{1}{1200\pi}\int_0^1\int_0^1 \theta\!\left(40u,\,30(1-u)v\right)\,1200(1-u)\,dv\,du.$$
实现最后除以的 \(1200\pi\) 正是从这里来的。
取 \(P=(10,10)\)。这时
$$a=(30,-10),\qquad b=(-10,20).$$
于是
$$\left\lvert a_x b_y-a_y b_x\right\rvert=\left\lvert 30\cdot 20-(-10)(-10)\right\rvert=500,$$
$$a_x b_x+a_y b_y=30(-10)+(-10)\cdot 20=-500.$$
所以
$$\theta(P)=\operatorname{atan2}(500,-500)=\frac{3\pi}{4},$$
从而该点的条件概率为
$$\mathbb{P}(AB\mid P)=\frac{3\pi/4}{2\pi}=\frac{3}{8}.$$
这个 \(3/8\) 只是某一个起点的局部结果，真正的最终答案还要继续对整个三角形内部取平均。
当区域已经变成 \([0,1]^2\) 后，就可以使用张量积形式的 Gauss-Legendre 求积。如果 \((u_i,w_i)\) 是 \([0,1]\) 上的一维节点和权重，那么
$$p\approx \frac{1}{1200\pi}\sum_{i=1}^n\sum_{j=1}^n w_i w_j\,\theta\!\left(40u_i,\,30(1-u_i)u_j\right)\,1200(1-u_i).$$
当 \(n\) 取到 \(1024\) 这样较高的阶数时，就足以稳定得到题目要求的 \(10\) 位小数输出。
C++、Python 和 Java 这三份实现都先构造 \([0,1]\) 上的一维 Gauss-Legendre 节点与权重。它们先在标准区间 \([-1,1]\) 上工作，利用 Legendre 多项式根的对称性，只显式求出一半的根，再用 Newton 迭代把根逐步收敛到高精度。多项式值和导数则通过经典的递推关系来计算，最后再把节点和权重统一缩放到 \([0,1]\)。
得到一维求积规则以后，程序构造二维张量积网格。外层循环对应参数 \(u\)，先计算出对应的 \(x\) 坐标以及雅可比因子 \(1200(1-u)\)；内层循环对应第二个参数，计算 \(y\) 坐标，形成从采样点指向斜边两个端点的向量，再用稳定的 \(\operatorname{atan2}\) 公式得到夹角，并把加权后的贡献累加到积分总和中。
双重求和结束后，程序再除以 \(1200\pi\)，把概率格式化为小数点后 \(10\) 位。C++ 实现还额外比较了 \(512\) 阶和 \(1024\) 阶求积结果，用来做一个数值一致性检查；Python 和 Java 实现则直接执行 \(1024\times 1024\) 的求积计算。
如果求积阶数为 \(n\)，那么生成一维 Gauss-Legendre 规则总体需要 \(O(n^2)\) 的算术操作，因为每个根的 Newton 迭代都会反复评估次数为 \(n\) 的 Legendre 递推。真正占主导的是二维张量积积分，它需要进行 \(n^2\) 次角度计算，所以总时间复杂度是 \(O(n^2)\)。存储方面只需要保留一维节点、权重以及少量标量，因此空间复杂度是 \(O(n)\)。
Расположим прямоугольный треугольник так: \(C=(0,0)\), \(A=(40,0)\), \(B=(0,30)\). Тогда катеты имеют длины \(40\) и \(30\), а гипотенуза равна стороне \(AB\) длины \(50\). Начальная точка \(P=(x,y)\) выбирается равномерно внутри треугольника, а направление движения также выбирается равномерно на интервале \([0,2\pi)\).
Нужно найти вероятность того, что луч впервые покинет треугольник именно через гипотенузу \(AB\), и округлить ответ до \(10\) знаков после запятой. Для такой точности простое моделирование методом Монте-Карло неудобно, поэтому решение переводит задачу в детерминированный двумерный интеграл и затем вычисляет его высокоточной квадратурой.
Главное геометрическое наблюдение таково: для фиксированной внутренней точки все направления, ведущие к гипотенузе, образуют один непрерывный угловой сектор.
Область треугольника имеет вид
$$T=\left\{(x,y): x\ge 0,\ y\ge 0,\ \frac{x}{40}+\frac{y}{30}\le 1\right\}.$$
Его площадь равна
$$\Delta=\frac{30\cdot 40}{2}=600.$$
Для любой внутренней точки \(P=(x,y)\) концами целевой стороны являются \(A=(40,0)\) и \(B=(0,30)\). Значит, всё сводится к вычислению угла, под которым отрезок \(AB\) виден из точки \(P\).
Зафиксируем \(P\in T\). Те и только те направления приведут к выходу через \(AB\), которые лежат между лучами \(PA\) и \(PB\). Мера этого множества направлений равна
$$\theta(P)=\angle APB.$$
Поскольку начальное направление равномерно распределено по полной окружности, имеем
$$\mathbb{P}(AB\mid P)=\frac{\theta(P)}{2\pi}.$$
Направления, попадающие точно в вершины, имеют нулевую меру и на среднее значение не влияют.
Запишем векторы от точки \(P\) к концам гипотенузы:
$$a=A-P=(40-x,-y),\qquad b=B-P=(-x,30-y).$$
Угол между двумя векторами удобно восстанавливать через модуль псевдовекторного произведения и скалярное произведение:
$$\theta(P)=\operatorname{atan2}\!\left(\left\lvert a_x b_y-a_y b_x\right\rvert,\ a_x b_x+a_y b_y\right).$$
Именно эта формула используется в реализации, потому что она численно устойчива и при очень малых углах, и при углах, близких к \(\pi\). В данной задаче числитель дополнительно упрощается:
$$\left\lvert a_x b_y-a_y b_x\right\rvert=1200-30x-40y,$$
то есть это удвоенная площадь треугольника \(APB\), положительная во всех внутренних точках.
Теперь усредним условную вероятность по равномерно распределённой точке \(P\):
$$p=\frac{1}{\Delta}\iint_T \frac{\theta(P)}{2\pi}\,dA=\frac{1}{2\pi\Delta}\iint_T \theta(x,y)\,dA.$$
Подставляя \(\Delta=600\), получаем
$$p=\frac{1}{1200\pi}\iint_T \theta(x,y)\,dA.$$
Таким образом, исходная вероятностная задача сводится к двумерному интегралу по треугольнику.
Для численного интегрирования удобно использовать замену переменных
$$x=40u,\qquad y=30(1-u)v,\qquad (u,v)\in[0,1]^2.$$
Она пробегает треугольник вертикальными отрезками: при \(u=0\) мы на левой стороне, а при \(u=1\) всё схлопывается в вершину \(A\). Определитель Якобиана равен
$$\left\lvert\frac{\partial(x,y)}{\partial(u,v)}\right\rvert=1200(1-u).$$
Следовательно,
$$p=\frac{1}{1200\pi}\int_0^1\int_0^1 \theta\!\left(40u,\,30(1-u)v\right)\,1200(1-u)\,dv\,du.$$
Именно отсюда появляется знаменатель \(1200\pi\) в конечной формуле программы.
Возьмём \(P=(10,10)\). Тогда
$$a=(30,-10),\qquad b=(-10,20).$$
Получаем
$$\left\lvert a_x b_y-a_y b_x\right\rvert=\left\lvert 30\cdot 20-(-10)(-10)\right\rvert=500,$$
$$a_x b_x+a_y b_y=30(-10)+(-10)\cdot 20=-500.$$
Значит,
$$\theta(P)=\operatorname{atan2}(500,-500)=\frac{3\pi}{4},$$
а условная вероятность в этой точке равна
$$\mathbb{P}(AB\mid P)=\frac{3\pi/4}{2\pi}=\frac{3}{8}.$$
Это лишь локальное значение; окончательный ответ появляется после усреднения по всему треугольнику.
После отображения области в \([0,1]^2\) интеграл аппроксимируется тензорным правилом Гаусса-Лежандра. Если \((u_i,w_i)\) обозначают одномерные узлы и веса на \([0,1]\), то
$$p\approx \frac{1}{1200\pi}\sum_{i=1}^n\sum_{j=1}^n w_i w_j\,\theta\!\left(40u_i,\,30(1-u_i)u_j\right)\,1200(1-u_i).$$
Высокий порядок, например \(n=1024\), даёт точность, достаточную для вывода ответа с \(10\) знаками после запятой.
Реализации на C++, Python и Java сначала строят одномерные узлы и веса Гаусса-Лежандра на \([0,1]\). Для этого они начинают со стандартного интервала \([-1,1]\), используют симметрию корней полиномов Лежандра, уточняют корни методом Ньютона и вычисляют значения полинома и его производной по стандартной рекуррентной формуле. Затем узлы и веса масштабируются на \([0,1]\).
После этого формируется двумерная тензорная сетка. Для каждого внешнего узла вычисляются соответствующая координата \(x\) и множитель Якобиана \(1200(1-u)\). Для каждого внутреннего узла вычисляется координата \(y\), строятся два вектора от точки выборки к концам гипотенузы, угол находится по устойчивой формуле с \(\operatorname{atan2}\), и взвешенный вклад добавляется к общей сумме интеграла.
Когда двойная сумма завершена, реализация делит результат на \(1200\pi\) и форматирует вероятность с \(10\) десятичными знаками. Реализация на C++ дополнительно сравнивает результаты квадратуры порядка \(512\) и \(1024\) как численную проверку, а реализации на Python и Java сразу вычисляют правило \(1024\times 1024\).
При порядке квадратуры \(n\) построение одномерного правила Гаусса-Лежандра требует в сумме \(O(n^2)\) арифметических операций, поскольку каждое уточнение корня использует рекуррентные вычисления полинома Лежандра степени \(n\). Главный вклад во время работы даёт двумерное тензорное интегрирование с \(n^2\) вычислениями угла. Поэтому общая временная сложность равна \(O(n^2)\), а потребление памяти составляет \(O(n)\), так как хранятся только одномерные узлы, веса и несколько скалярных величин.
نضع المثلث القائم في المستوى بحيث تكون النقاط \(C=(0,0)\) و\(A=(40,0)\) و\(B=(0,30)\). عندئذ يكون طول الضلعين القائمين \(40\) و\(30\)، ويكون الوتر هو القطعة \(AB\) وطولها \(50\). تُختار نقطة البداية \(P=(x,y)\) عشوائيًا وبانتظام من داخل المثلث، كما يُختار اتجاه الحركة الأولي بانتظام من المجال \([0,2\pi)\).
المطلوب هو احتمال أن يكون أول ضلع يقطعه المسار عند خروجه من المثلث هو الوتر \(AB\)، مع تقريب الناتج إلى \(10\) منازل عشرية. ولأن هذه الدقة لا تناسب المحاكاة العشوائية البسيطة، يُعاد صياغة المسألة على شكل تكامل مساحي محدد ثم يُحسب عدديًا بطريقة تربيع عالية الدقة.
الفكرة الهندسية الأساسية هي أن الاتجاهات التي تقود إلى الوتر، عند تثبيت نقطة داخلية واحدة، تشكل مجالًا زاويًا متصلًا واحدًا.
منطقة المثلث هي
$$T=\left\{(x,y): x\ge 0,\ y\ge 0,\ \frac{x}{40}+\frac{y}{30}\le 1\right\}.$$
ومساحته
$$\Delta=\frac{30\cdot 40}{2}=600.$$
ولأي نقطة داخلية \(P=(x,y)\)، فإن طرفي الضلع المطلوب هما \(A=(40,0)\) و\(B=(0,30)\). لذلك تصبح المسألة كلها مسألة حساب الزاوية التي ترى بها القطعة \(AB\) من النقطة \(P\).
لنثبت نقطة داخلية \(P\in T\). الاتجاهات التي تجعل المسار يخرج عبر \(AB\) هي تمامًا الاتجاهات الواقعة بين الشعاعين \(PA\) و\(PB\). قياس هذا المجال الزاوي هو
$$\theta(P)=\angle APB.$$
وبما أن الاتجاه الابتدائي موزع بانتظام على الدائرة كاملة، فإن
$$\mathbb{P}(AB\mid P)=\frac{\theta(P)}{2\pi}.$$
أما الاتجاهات التي تصيب رأسًا من رؤوس المثلث بالضبط فهي مجموعة ذات قياس صفري، ولذلك لا تؤثر في المتوسط النهائي.
لنكتب المتجهين من \(P\) إلى طرفي الوتر على الصورة
$$a=A-P=(40-x,-y),\qquad b=B-P=(-x,30-y).$$
يمكن استرجاع الزاوية بين متجهين بطريقة مستقرة من خلال المزج بين مقدار الضرب الاتجاهي والضرب القياسي:
$$\theta(P)=\operatorname{atan2}\!\left(\left\lvert a_x b_y-a_y b_x\right\rvert,\ a_x b_x+a_y b_y\right).$$
هذه هي الصيغة المستخدمة في التنفيذ فعليًا، لأنها تتصرف جيدًا عندما تكون الزاوية صغيرة جدًا أو قريبة من \(\pi\). وفي هذا المثلث تحديدًا يتبسط البسط إلى
$$\left\lvert a_x b_y-a_y b_x\right\rvert=1200-30x-40y,$$
وهو يساوي ضعفي مساحة المثلث \(APB\)، ولذلك يبقى موجبًا لكل نقطة داخلية.
نأخذ الآن متوسط الاحتمال الشرطي على جميع النقاط الداخلية الموزعة بانتظام:
$$p=\frac{1}{\Delta}\iint_T \frac{\theta(P)}{2\pi}\,dA=\frac{1}{2\pi\Delta}\iint_T \theta(x,y)\,dA.$$
ومع \(\Delta=600\) نحصل على
$$p=\frac{1}{1200\pi}\iint_T \theta(x,y)\,dA.$$
وهكذا تتحول المسألة إلى تكامل ثنائي البعد على منطقة مثلثية.
من أجل التكامل العددي، يكون التغيير
$$x=40u,\qquad y=30(1-u)v,\qquad (u,v)\in[0,1]^2$$
مفيدًا جدًا. هذا التمثيل يمسح المثلث بمقاطع رأسية: عندما \(u=0\) نكون على الضلع الأيسر، وعندما \(u=1\) ينكمش المقطع كله إلى الرأس \(A\). محدد يعقوبي التحويل هو
$$\left\lvert\frac{\partial(x,y)}{\partial(u,v)}\right\rvert=1200(1-u).$$
إذن يصبح التكامل
$$p=\frac{1}{1200\pi}\int_0^1\int_0^1 \theta\!\left(40u,\,30(1-u)v\right)\,1200(1-u)\,dv\,du.$$
ومن هنا يظهر المقام \(1200\pi\) الذي تقسم عليه النتيجة في النهاية.
لنأخذ \(P=(10,10)\). عندئذ
$$a=(30,-10),\qquad b=(-10,20).$$
ومن ثم
$$\left\lvert a_x b_y-a_y b_x\right\rvert=\left\lvert 30\cdot 20-(-10)(-10)\right\rvert=500,$$
$$a_x b_x+a_y b_y=30(-10)+(-10)\cdot 20=-500.$$
لذلك
$$\theta(P)=\operatorname{atan2}(500,-500)=\frac{3\pi}{4},$$
ويكون الاحتمال الشرطي عند هذه النقطة
$$\mathbb{P}(AB\mid P)=\frac{3\pi/4}{2\pi}=\frac{3}{8}.$$
هذه القيمة محلية فقط، أما الناتج النهائي فيأتي بعد أخذ المتوسط على كامل داخل المثلث.
بعد نقل المجال إلى \([0,1]^2\)، يُقرب التكامل بقاعدة غاوس-ليجندر على شكل حاصل ضرب موتر. إذا كانت \((u_i,w_i)\) هي العقد والأوزان أحادية البعد على \([0,1]\)، فإن
$$p\approx \frac{1}{1200\pi}\sum_{i=1}^n\sum_{j=1}^n w_i w_j\,\theta\!\left(40u_i,\,30(1-u_i)u_j\right)\,1200(1-u_i).$$
واختيار رتبة كبيرة مثل \(n=1024\) يكفي للوصول إلى الدقة المطلوبة لطباعة \(10\) منازل عشرية.
تبدأ تطبيقات C++ وPython وJava ببناء عقد وأوزان غاوس-ليجندر على الفترة \([0,1]\). وهي تفعل ذلك أولًا على الفترة القياسية \([-1,1]\)، وتستفيد من تناظر جذور كثيرة حدود ليجندر بحيث لا يلزم حساب إلا نصفها صراحة، ثم تُحسن هذه الجذور بطريقة نيوتن، وتحسب قيم كثير الحدود ومشتقته من خلال العلاقة التراجعية القياسية. بعد ذلك تُعاد معايرة العقد والأوزان إلى الفترة \([0,1]\).
بعد تجهيز قاعدة التكامل أحادي البعد، يبني التنفيذ شبكة موترية ثنائية البعد. في الحلقة الخارجية تُحسب قيمة \(x\) الموافقة وعامل يعقوبي \(1200(1-u)\). وفي الحلقة الداخلية تُحسب قيمة \(y\)، ثم يُبنى المتجهان من نقطة العينة إلى طرفي الوتر، وتُحسب الزاوية بصيغة \(\operatorname{atan2}\) المستقرة، ثم تُضاف المساهمة الموزونة إلى مجموع التكامل.
بعد انتهاء الجمع المزدوج، يقسم التنفيذ الناتج على \(1200\pi\) ويطبع الاحتمال إلى \(10\) منازل عشرية. ويضيف تنفيذ C++ مقارنة بين رتبتين \(512\) و\(1024\) كتأكد عددي صغير، بينما ينفذ كل من Python وJava مباشرة قاعدة \(1024\times 1024\).
إذا كانت رتبة التربيع \(n\)، فإن بناء قاعدة غاوس-ليجندر أحادية البعد يحتاج إجمالًا إلى \(O(n^2)\) عملية حسابية، لأن تحسين كل جذر يتطلب تقييم علاقات ليجندر التراجعية من الدرجة \(n\). لكن الجزء المسيطر فعليًا هو التكامل الموتر ثنائي البعد، إذ يجري \(n^2\) عملية تقييم للزاوية. لذلك يكون التعقيد الزمني الكلي \(O(n^2)\)، بينما يكون استهلاك الذاكرة \(O(n)\)، لأن التخزين يقتصر على العقد والأوزان أحادية البعد وبعض القيم العددية القليلة.