AJO_1516_Ejemplo_poligonal_Tindouf

hace 140 días por etlopez

Dados tres puntos A, B, C conocemos las coordenadas de A, las tres distancias y los tres acimutes, con las precisiones indicadas.

Debajo está el ajuste con las ocho observaciones (caso 1), descartando una observación (casos 2a y 2b), y descartando dos observaciones (caso 3). La hoja está preparada para ser ejecutada de principio a fin (menú "Action" / "Evaluate all"). Se comparan los cuatro métodos mostrando juntas las elipses de error.

 

Caso 1: con las ocho mediciones

reset() 
       
lxA,lyA,sxA,syA = 711708,2969077,1,1 ldAB,sdAB = 120513.825,0.050 laAB,saAB = -58.8554,0.0020 ldBC,sdBC = 33309.819,0.029 laBC,saBC = -38.5767,0.0020 ldAC,sdAC = 152504.929,0.057 laAC,saAC = -54.4977,0.0020 SigmaL = diagonal_matrix([sxA^2,syA^2,sdAB^2,saAB^2,sdBC^2,saBC^2,sdAC^2,saAC^2]) vdr = 1 QL = 1/vdr*SigmaL P = QL^(-1) var('xA,yA,xB,yB,xC,yC') F(xA,yA,xB,yB,xC,yC) = ( xA , yA , sqrt((xA-xB)^2+(yA-yB)^2) , 200/pi*atan2(xB-xA,yB-yA) , sqrt((xB-xC)^2+(yB-yC)^2) , 200/pi*atan2(xC-xB,yC-yB) , sqrt((xA-xC)^2+(yA-yC)^2) , 200/pi*atan2(xC-xA,yC-yA) ) 
       
# con algunos datos sacamos unos valores iniciales para debajo lxA+ldAB*sin(pi/200*laAB).n(),lyA+ldAB*cos(pi/200*laAB).n(); lxA+ldAC*sin(pi/200*laAC).n(),lyA+ldAC*cos(pi/200*laAC).n() 
       
(615499.545499591, 3.04165465013262e6)
(596527.412006225, 3.06903291787735e6)
(615499.545499591, 3.04165465013262e6)
(596527.412006225, 3.06903291787735e6)
# con algunos valores iniciales y lo de arriba vemos que F funciona X0 = vector([711708,2969077,615499,3.04165*10^6,596527,3.069032*10^6]).column() F(*X0.column(0)).n() 
       
(711708.000000000, 2.96907700000000e6, 120511.460077455,
-58.8575346167924, 33312.3206636824, -38.5741021183741,
152504.638572078, -54.4981021121027)
(711708.000000000, 2.96907700000000e6, 120511.460077455, -58.8575346167924, 33312.3206636824, -38.5741021183741, 152504.638572078, -54.4981021121027)
point((X0[0,0],X0[1,0]),figsize=4,aspect_ratio=1) + point((X0[2,0],X0[3,0])) + point((X0[4,0],X0[5,0])) 
       
L = vector([lxA,lyA,ldAB,laAB,ldBC,laBC,ldAC,laAC]).column() L 
       
[  711708.000000000]
[2.96907700000000e6]
[  120513.825000000]
[ -58.8554000000000]
[  33309.8190000000]
[ -38.5767000000000]
[  152504.929000000]
[ -54.4977000000000]
[  711708.000000000]
[2.96907700000000e6]
[  120513.825000000]
[ -58.8554000000000]
[  33309.8190000000]
[ -38.5767000000000]
[  152504.929000000]
[ -54.4977000000000]
J0 = jacobian(F,(xA,yA,xB,yB,xC,yC))(*X0.column(0)).n() N0 = transpose(J0)*P*J0 QX0 = N0^(-1) SigmaX0 = vdr*QX0 map(sqrt,SigmaX0.diagonal()) 
       
[0.999999999999984,
 1.00000000000003,
 1.68105432037324,
 2.04211289324187,
 2.07640109679993,
 2.32838046731857]
[0.999999999999984,
 1.00000000000003,
 1.68105432037324,
 2.04211289324187,
 2.07640109679993,
 2.32838046731857]
V0 = L - F(*X0.column(0)).column().n() sumaV0 = transpose(V0)*P*V0 sumaV0 = sumaV0[0,0] sumaV0 
       
9707.49501137664
9707.49501137664
DeltaL0 = L - F(*X0.column(0)).column() DeltaX0 = (transpose(J0)*P*J0)^(-1) * (transpose(J0)*P*DeltaL0) DeltaX0 = DeltaX0.n() DeltaX0 
       
[-2.27459295385929e-12]
[ 3.08128058256497e-13]
[   -0.478501467579918]
[     3.28493400232401]
[    0.258302558460855]
[    0.750106082778075]
[-2.27459295385929e-12]
[ 3.08128058256497e-13]
[   -0.478501467579918]
[     3.28493400232401]
[    0.258302558460855]
[    0.750106082778075]
X1 = X0 + DeltaX0 V1 = L - F(*X1.column(0)).column().n() sumaV1 = transpose(V1)*P*V1 sumaV1 = sumaV1[0,0] sumaV0; sumaV1 
       
9707.49501137664
0.476637963489154
9707.49501137664
0.476637963489154
J1 = jacobian(F,(xA,yA,xB,yB,xC,yC))(*X1.column(0)).n() DeltaL1 = L - F(*X1.column(0)).column() DeltaX1 = (transpose(J1)*P*J1)^(-1) * (transpose(J1)*P*DeltaL1) DeltaX1 = DeltaX1.n() DeltaX1 
       
[-2.16743268396175e-12]
[-6.86121058552138e-13]
[ 0.000183353964530397]
[ 0.000205556207220070]
[ 0.000148964885738678]
[ 0.000168896833201870]
[-2.16743268396175e-12]
[-6.86121058552138e-13]
[ 0.000183353964530397]
[ 0.000205556207220070]
[ 0.000148964885738678]
[ 0.000168896833201870]
X2 = X1 + DeltaX1 V2 = L - F(*X2.column(0)).column().n() sumaV2 = transpose(V2)*P*V2 sumaV2 = sumaV2[0,0] sumaV0; sumaV1; sumaV2 
       
9707.49501137664
0.476637963489154
0.476637616456068
9707.49501137664
0.476637963489154
0.476637616456068
X2 
       
[  711708.000000000]
[2.96907700000000e6]
[  615498.521681886]
[3.04165328513956e6]
[  596527.258451523]
[3.06903275027498e6]
[  711708.000000000]
[2.96907700000000e6]
[  615498.521681886]
[3.04165328513956e6]
[  596527.258451523]
[3.06903275027498e6]
J2 = jacobian(F,(xA,yA,xB,yB,xC,yC))(*X2.column(0)).n() N2 = transpose(J2)*P*J2 QX2 = N2^(-1) SigmaX2 = QX2 map(sqrt,SigmaX2.diagonal()) 
       
[0.999999999999947,
 0.999999999999987,
 1.68111182728703,
 2.04213157783590,
 2.07641629016594,
 2.32838123359199]
[0.999999999999947,
 0.999999999999987,
 1.68111182728703,
 2.04213157783590,
 2.07641629016594,
 2.32838123359199]
map(sqrt,SigmaX0.diagonal()) 
       
[0.999999999999984,
 1.00000000000003,
 1.68105432037324,
 2.04211289324187,
 2.07640109679993,
 2.32838046731857]
[0.999999999999984,
 1.00000000000003,
 1.68105432037324,
 2.04211289324187,
 2.07640109679993,
 2.32838046731857]
redund = L.nrows() - X0.nrows() vdr_estim = sumaV2/redund vdr_estim 
       
0.238318808228034
0.238318808228034
puntoA = X2[0,0],X2[1,0] puntoB = X2[2,0],X2[3,0] puntoC = X2[4,0],X2[5,0] SigmaA = SigmaX2.matrix_from_rows_and_columns([0,1],[0,1]) SigmaB = SigmaX2.matrix_from_rows_and_columns([2,3],[2,3]) SigmaC = SigmaX2.matrix_from_rows_and_columns([4,5],[4,5]) def elipse(centro,matriz,prob,color="blue"): c = sqrt(r.qchisq(prob,2))._sage_() e = map(sqrt,matriz.eigenvalues()) smax = max(e).n() smin = min(e).n() try: alfa = arctan(matriz[0,1]/(smax^2-matriz[0,0])) except ZeroDivisionError: alfa = 0 return ellipse(centro, c*smax, c*smin, pi/2-alfa, color=color) color = "blue" 
       
plotAcaso1 = elipse(puntoA,SigmaA,0.95,color=color) + point(puntoA,color=color) plotAcaso1.show(figsize=2) 
       
__main__:12: UserWarning: Using generic algorithm for an inexact ring,
which will probably give incorrect results due to numerical precision
issues.
__main__:12: UserWarning: Using generic algorithm for an inexact ring, which will probably give incorrect results due to numerical precision issues.
plotBcaso1 = elipse(puntoB,SigmaB,0.95,color=color) + point(puntoB,color=color) plotBcaso1.show(figsize=2) 
       
plotCcaso1 = elipse(puntoC,SigmaC,0.95,color=color) + point(puntoC,color=color) plotCcaso1.show(figsize=2) 
       
 
       

Caso 2a: con siete mediciones (quitamos el acimut de AC)

lxA,lyA,sxA,syA = 711708,2969077,1,1 ldAB,sdAB = 120513.825,0.050 laAB,saAB = -58.8554,0.0020 ldBC,sdBC = 33309.819,0.029 laBC,saBC = -38.5767,0.0020 ldAC,sdAC = 152504.929,0.057 SigmaL = diagonal_matrix([sxA^2,syA^2,sdAB^2,saAB^2,sdBC^2,saBC^2,sdAC^2]) QL = SigmaL P = QL^(-1) var('xA,yA,xB,yB,xC,yC') F(xA,yA,xB,yB,xC,yC) = ( xA , yA , sqrt((xA-xB)^2+(yA-yB)^2) , 200/pi*atan2(xB-xA,yB-yA) , sqrt((xB-xC)^2+(yB-yC)^2) , 200/pi*atan2(xC-xB,yC-yB) , sqrt((xA-xC)^2+(yA-yC)^2) ) L = vector([lxA,lyA,ldAB,laAB,ldBC,laBC,ldAC]).column() L 
       
[  711708.000000000]
[2.96907700000000e6]
[  120513.825000000]
[ -58.8554000000000]
[  33309.8190000000]
[ -38.5767000000000]
[  152504.929000000]
[  711708.000000000]
[2.96907700000000e6]
[  120513.825000000]
[ -58.8554000000000]
[  33309.8190000000]
[ -38.5767000000000]
[  152504.929000000]
F(*X0.column(0)).n() 
       
(711708.000000000, 2.96907700000000e6, 120511.460077455,
-58.8575346167924, 33312.3206636824, -38.5741021183741,
152504.638572078)
(711708.000000000, 2.96907700000000e6, 120511.460077455, -58.8575346167924, 33312.3206636824, -38.5741021183741, 152504.638572078)
J0 = jacobian(F,(xA,yA,xB,yB,xC,yC))(*X0.column(0)).n() N0 = transpose(J0)*P*J0 QX0 = N0^(-1) SigmaX0 = QX0 map(sqrt,SigmaX0.diagonal()) 
       
[0.999999999999989,
 1.00000000000014,
 1.93336153214587,
 2.40077864019752,
 2.44780553452051,
 2.76864515948413]
[0.999999999999989,
 1.00000000000014,
 1.93336153214587,
 2.40077864019752,
 2.44780553452051,
 2.76864515948413]
V0 = L - F(*X0.column(0)).column().n() sumaV0 = transpose(V0)*P*V0 sumaV0 = sumaV0[0,0] sumaV0 
       
9707.45458784084
9707.45458784084
DeltaL0 = L - F(*X0.column(0)).column() DeltaX0 = (transpose(J0)*P*J0)^(-1) * (transpose(J0)*P*DeltaL0) DeltaX0 = DeltaX0.n() X1 = X0 + DeltaX0 V1 = L - F(*X1.column(0)).column().n() sumaV1 = transpose(V1)*P*V1 sumaV1 = sumaV1[0,0] DeltaX0; sumaV0; sumaV1 
       
[-3.78003806646194e-12]
[-1.80564707559629e-14]
[   -0.534168132369814]
[     3.21134903228085]
[    0.182740101517993]
[    0.662783484833199]
9707.45458784084
0.473246630971819
[-3.78003806646194e-12]
[-1.80564707559629e-14]
[   -0.534168132369814]
[     3.21134903228085]
[    0.182740101517993]
[    0.662783484833199]
9707.45458784084
0.473246630971819
J1 = jacobian(F,(xA,yA,xB,yB,xC,yC))(*X1.column(0)).n() DeltaL1 = L - F(*X1.column(0)).column() DeltaX1 = (transpose(J1)*P*J1)^(-1) * (transpose(J1)*P*DeltaL1) DeltaX1 = DeltaX1.n() X2 = X1 + DeltaX1 V2 = L - F(*X2.column(0)).column().n() sumaV2 = transpose(V2)*P*V2 sumaV2 = sumaV2[0,0] DeltaX1; sumaV0; sumaV1; sumaV2 
       
[-1.56645271481807e-12]
[ 3.02898340907905e-13]
[ 0.000234998900850769]
[ 0.000276767488685437]
[ 0.000222251299419440]
[ 0.000254318088991567]
9707.45458784084
0.473246630971819
0.473246296653619
[-1.56645271481807e-12]
[ 3.02898340907905e-13]
[ 0.000234998900850769]
[ 0.000276767488685437]
[ 0.000222251299419440]
[ 0.000254318088991567]
9707.45458784084
0.473246630971819
0.473246296653619
X2 
       
[  711708.000000000]
[2.96907700000000e6]
[  615498.466066867]
[3.04165321162580e6]
[  596527.182962353]
[3.06903266303780e6]
[  711708.000000000]
[2.96907700000000e6]
[  615498.466066867]
[3.04165321162580e6]
[  596527.182962353]
[3.06903266303780e6]
J2 = jacobian(F,(xA,yA,xB,yB,xC,yC))(*X2.column(0)).n() N2 = transpose(J2)*P*J2 QX2 = N2^(-1) SigmaX2 = QX2 map(sqrt,SigmaX2.diagonal()) 
       
[1.00000000000004,
 0.999999999999965,
 1.93343617618977,
 2.40080528172065,
 2.44782563526746,
 2.76865059505882]
[1.00000000000004,
 0.999999999999965,
 1.93343617618977,
 2.40080528172065,
 2.44782563526746,
 2.76865059505882]
map(sqrt,SigmaX0.diagonal()) 
       
[0.999999999999989,
 1.00000000000014,
 1.93336153214587,
 2.40077864019752,
 2.44780553452051,
 2.76864515948413]
[0.999999999999989,
 1.00000000000014,
 1.93336153214587,
 2.40077864019752,
 2.44780553452051,
 2.76864515948413]
redund = L.nrows() - X0.nrows() vdr_estim = sumaV2/redund vdr_estim 
       
0.473246296653619
0.473246296653619
puntoA = X2[0,0],X2[1,0] puntoB = X2[2,0],X2[3,0] puntoC = X2[4,0],X2[5,0] SigmaA = SigmaX2.submatrix(row=0, col=0, nrows=2, ncols=2) SigmaB = SigmaX2.submatrix(row=2, col=2, nrows=2, ncols=2) SigmaC = SigmaX2.submatrix(row=4, col=4, nrows=2, ncols=2) color = "green" 
       
plotAcaso2a = elipse(puntoA,SigmaA,0.95,color=color) + point(puntoA,color=color) plotAcaso2a.show(figsize=2) 
       
plotBcaso2a = elipse(puntoB,SigmaB,0.95,color=color) + point(puntoB,color=color) plotBcaso2a.show(figsize=2) 
       
plotCcaso2a = elipse(puntoC,SigmaC,0.95,color=color) + point(puntoC,color=color) plotCcaso2a.show(figsize=2) 
       
(plotAcaso1 + plotAcaso2a).show(figsize=4);(plotBcaso1 + plotBcaso2a).show(figsize=4);(plotCcaso1 + plotCcaso2a).show(figsize=4) 
       


Caso 2b: con siete mediciones (quitamos la distancia AC)

lxA,lyA,sxA,syA = 711708,2969077,1,1 ldAB,sdAB = 120513.825,0.050 laAB,saAB = -58.8554,0.0020 ldBC,sdBC = 33309.819,0.029 laBC,saBC = -38.5767,0.0020 laAC,saAC = -54.4977,0.0020 SigmaL = diagonal_matrix([sxA^2,syA^2,sdAB^2,saAB^2,sdBC^2,saBC^2,saAC^2]) QL = SigmaL P = QL^(-1) var('xA,yA,xB,yB,xC,yC') F(xA,yA,xB,yB,xC,yC) = ( xA , yA , sqrt((xA-xB)^2+(yA-yB)^2) , 200/pi*atan2(xB-xA,yB-yA) , sqrt((xB-xC)^2+(yB-yC)^2) , 200/pi*atan2(xC-xB,yC-yB) , 200/pi*atan2(xC-xA,yC-yA) ) L = vector([lxA,lyA,ldAB,laAB,ldBC,laBC,laAC]).column() L 
       
[  711708.000000000]
[2.96907700000000e6]
[  120513.825000000]
[ -58.8554000000000]
[  33309.8190000000]
[ -38.5767000000000]
[ -54.4977000000000]
[  711708.000000000]
[2.96907700000000e6]
[  120513.825000000]
[ -58.8554000000000]
[  33309.8190000000]
[ -38.5767000000000]
[ -54.4977000000000]
F(*X0.column(0)).n() 
       
(711708.000000000, 2.96907700000000e6, 120511.460077455,
-58.8575346167924, 33312.3206636824, -38.5741021183741,
-54.4981021121027)
(711708.000000000, 2.96907700000000e6, 120511.460077455, -58.8575346167924, 33312.3206636824, -38.5741021183741, -54.4981021121027)
J0 = jacobian(F,(xA,yA,xB,yB,xC,yC))(*X0.column(0)).n() N0 = transpose(J0)*P*J0 QX0 = N0^(-1) SigmaX0 = QX0 map(sqrt,SigmaX0.diagonal()) 
       
[0.999999999999996,
 0.999999999999985,
 2.06417861968332,
 2.59403252744377,
 2.14207853004992,
 2.59121615706372]
[0.999999999999996,
 0.999999999999985,
 2.06417861968332,
 2.59403252744377,
 2.14207853004992,
 2.59121615706372]
V0 = L - F(*X0.column(0)).column().n() sumaV0 = transpose(V0)*P*V0 sumaV0 = sumaV0[0,0] sumaV0 
       
9681.53367614946
9681.53367614946
DeltaL0 = L - F(*X0.column(0)).column() DeltaX0 = (transpose(J0)*P*J0)^(-1) * (transpose(J0)*P*DeltaL0) DeltaX0 = DeltaX0.n() X1 = X0 + DeltaX0 V1 = L - F(*X1.column(0)).column().n() sumaV1 = transpose(V1)*P*V1 sumaV1 = sumaV1[0,0] DeltaX0; sumaV0; sumaV1 
       
[-4.32115022491723e-12]
[-2.69588723457070e-12]
[    0.327022851037327]
[     4.36062079704425]
[    0.612263591610827]
[     1.51478005123499]
9681.53367614946
0.0246054777097496
[-4.32115022491723e-12]
[-2.69588723457070e-12]
[    0.327022851037327]
[     4.36062079704425]
[    0.612263591610827]
[     1.51478005123499]
9681.53367614946
0.0246054777097496
J1 = jacobian(F,(xA,yA,xB,yB,xC,yC))(*X1.column(0)).n() DeltaL1 = L - F(*X1.column(0)).column() DeltaX1 = (transpose(J1)*P*J1)^(-1) * (transpose(J1)*P*DeltaL1) DeltaX1 = DeltaX1.n() X2 = X1 + DeltaX1 V2 = L - F(*X2.column(0)).column().n() sumaV2 = transpose(V2)*P*V2 sumaV2 = sumaV2[0,0] DeltaX1; sumaV0; sumaV1; sumaV2 
       
[  3.49544071385376e-12]
[  2.18959481158555e-12]
[ 0.0000485226046293974]
[-0.0000288840528810397]
[  0.000148330975207500]
[   5.17982698511332e-6]
9681.53367614946
0.0246054777097496
0.0246032180746028
[  3.49544071385376e-12]
[  2.18959481158555e-12]
[ 0.0000485226046293974]
[-0.0000288840528810397]
[  0.000148330975207500]
[   5.17982698511332e-6]
9681.53367614946
0.0246054777097496
0.0246032180746028
X2 
       
[  711708.000000000]
[2.96907700000000e6]
[  615499.327071374]
[3.04165436059191e6]
[  596527.612411923]
[3.06903351478523e6]
[  711708.000000000]
[2.96907700000000e6]
[  615499.327071374]
[3.04165436059191e6]
[  596527.612411923]
[3.06903351478523e6]
J2 = jacobian(F,(xA,yA,xB,yB,xC,yC))(*X2.column(0)).n() N2 = transpose(J2)*P*J2 QX2 = N2^(-1) SigmaX2 = QX2 map(sqrt,SigmaX2.diagonal()) 
       
[1.00000000000008,
 1.00000000000019,
 2.06426149626820,
 2.59400827345738,
 2.14213339624725,
 2.59119540536776]
[1.00000000000008,
 1.00000000000019,
 2.06426149626820,
 2.59400827345738,
 2.14213339624725,
 2.59119540536776]
map(sqrt,SigmaX0.diagonal()) 
       
[0.999999999999996,
 0.999999999999985,
 2.06417861968332,
 2.59403252744377,
 2.14207853004992,
 2.59121615706372]
[0.999999999999996,
 0.999999999999985,
 2.06417861968332,
 2.59403252744377,
 2.14207853004992,
 2.59121615706372]
redund = L.nrows() - X0.nrows() vdr_estim = sumaV2/redund vdr_estim 
       
0.0246032180746028
0.0246032180746028
puntoA = X2[0,0],X2[1,0] puntoB = X2[2,0],X2[3,0] puntoC = X2[4,0],X2[5,0] SigmaA = SigmaX2.submatrix(row=0, col=0, nrows=2, ncols=2) SigmaB = SigmaX2.submatrix(row=2, col=2, nrows=2, ncols=2) SigmaC = SigmaX2.submatrix(row=4, col=4, nrows=2, ncols=2) color = "black" 
       
plotAcaso2b = elipse(puntoA,SigmaA,0.95,color=color) + point(puntoA,color=color) plotAcaso2b.show(figsize=2) 
       
plotBcaso2b = elipse(puntoB,SigmaB,0.95,color=color) + point(puntoB,color=color) plotBcaso2b.show(figsize=2) 
       
plotCcaso2b = elipse(puntoC,SigmaC,0.95,color=color) + point(puntoC,color=color) plotCcaso2b.show(figsize=2) 
       
(plotAcaso1 + plotAcaso2a + plotAcaso2b).show(figsize=4);(plotBcaso1 + plotBcaso2a + plotBcaso2b).show(figsize=4);(plotCcaso1 + plotCcaso2a + plotCcaso2b).show(figsize=4) 
       


 
       

Caso 3: con seis mediciones (quitamos las dos de AC), ¡ya no es un ajuste!

lxA,lyA,sxA,syA = 711708,2969077,1,1 ldAB,sdAB = 120513.825,0.050 laAB,saAB = -58.8554,0.0020 ldBC,sdBC = 33309.819,0.029 laBC,saBC = -38.5767,0.0020 var('xA,yA,dAB,aAB,dBC,aBC') F(xA,yA,dAB,aAB,dBC,aBC) = ( xA , yA , xA+dAB*sin(pi/200*aAB) , yA+dAB*cos(pi/200*aAB) , xA+dAB*sin(pi/200*aAB)+dBC*sin(pi/200*aBC) , yA+dAB*cos(pi/200*aAB)+dBC*cos(pi/200*aBC) ) 
       
X = F(lxA,lyA,ldAB,laAB,ldBC,laBC).column().n() X 
       
[  711708.000000000]
[2.96907700000000e6]
[  615499.545499591]
[3.04165465013262e6]
[  596527.852955307]
[3.06903381965651e6]
[  711708.000000000]
[2.96907700000000e6]
[  615499.545499591]
[3.04165465013262e6]
[  596527.852955307]
[3.06903381965651e6]
J = jacobian(F,(xA,yA,dAB,aAB,dBC,aBC))(lxA,lyA,ldAB,laAB,ldBC,laBC).n() SigmaL = diagonal_matrix([sxA^2,syA^2,sdAB^2,saAB^2,sdBC^2,saBC^2]) SigmaX = J * SigmaL * transpose(J) map(sqrt,SigmaX.diagonal()) 
       
[1.00000000000000,
 1.00000000000000,
 2.49006475817429,
 3.18375225146319,
 2.63449037480736,
 3.23914779525011]
[1.00000000000000,
 1.00000000000000,
 2.49006475817429,
 3.18375225146319,
 2.63449037480736,
 3.23914779525011]
puntoA = X[0,0],X[1,0] puntoB = X[2,0],X[3,0] puntoC = X[4,0],X[5,0] SigmaA = SigmaX.matrix_from_rows_and_columns([0,1],[0,1]) SigmaB = SigmaX.matrix_from_rows_and_columns([2,3],[2,3]) SigmaC = SigmaX.matrix_from_rows_and_columns([4,5],[4,5]) color = "red" 
       
plotAcaso3 = elipse(puntoA,SigmaA,0.95,color=color) + point(puntoA,color=color) plotAcaso3.show(figsize=2) 
       
plotBcaso3 = elipse(puntoB,SigmaB,0.95,color=color) + point(puntoB,color=color) plotBcaso3.show(figsize=2) 
       
plotCcaso3 = elipse(puntoC,SigmaC,0.95,color=color) + point(puntoC,color=color) plotCcaso3.show(figsize=2) 
       
(plotAcaso1 + plotAcaso2a + plotAcaso2b + plotAcaso3).show(figsize=4);(plotBcaso1 + plotBcaso2a + plotBcaso2b + plotBcaso3).show(figsize=4);(plotCcaso1 + plotCcaso2a + plotCcaso2b + plotCcaso3).show(figsize=4)